cmd2 2.4.3__py3-none-any.whl → 2.5.0__py3-none-any.whl

cmd2/command_definition.py

@@ -2,6 +2,7 @@
 """
 Supports the definition of commands in separate classes to be composed into cmd2.Cmd
 """
+
 from typing import (
     TYPE_CHECKING,
     Callable,
@@ -165,3 +166,12 @@ class CommandSet(object):
             del self._settables[name]
         except KeyError:
             raise KeyError(name + " is not a settable parameter")
+
+    def sigint_handler(self) -> bool:
+        """
+        Handle a SIGINT that occurred for a command in this CommandSet.
+
+        :return: True if this completes the interrupt handling and no KeyboardInterrupt will be raised.
+                 False to raise a KeyboardInterrupt.
+        """
+        return False

cmd2/decorators.py

@@ -1,5 +1,6 @@
 # coding=utf-8
 """Decorators for ``cmd2`` commands"""
+
 import argparse
 from typing import (
     TYPE_CHECKING,
@@ -10,7 +11,9 @@ from typing import (
     Optional,
     Sequence,
     Tuple,
+    TypeVar,
     Union,
+    overload,
 )
 
 from . import (
@@ -29,9 +32,6 @@ from .exceptions import (
 from .parsing import (
     Statement,
 )
-from .utils import (
-    strip_doc_annotations,
-)
 
 if TYPE_CHECKING:  # pragma: no cover
     import cmd2
@@ -72,7 +72,10 @@ def with_category(category: str) -> Callable[[CommandFunc], CommandFunc]:
 ##########################
 
 
-RawCommandFuncOptionalBoolReturn = Callable[[Union[CommandSet, 'cmd2.Cmd'], Union[Statement, str]], Optional[bool]]
+CommandParent = TypeVar('CommandParent', bound=Union['cmd2.Cmd', CommandSet])
+
+
+RawCommandFuncOptionalBoolReturn = Callable[[CommandParent, Union[Statement, str]], Optional[bool]]
 
 
 def _parse_positionals(args: Tuple[Any, ...]) -> Tuple['cmd2.Cmd', Union[Statement, str]]:
@@ -116,38 +119,36 @@ def _arg_swap(args: Union[Sequence[Any]], search_arg: Any, *replace_arg: Any) ->
 
 #: Function signature for an Command Function that accepts a pre-processed argument list from user input
 #: and optionally returns a boolean
-ArgListCommandFuncOptionalBoolReturn = Union[
-    Callable[['cmd2.Cmd', List[str]], Optional[bool]],
-    Callable[[CommandSet, List[str]], Optional[bool]],
-]
+ArgListCommandFuncOptionalBoolReturn = Callable[[CommandParent, List[str]], Optional[bool]]
 #: Function signature for an Command Function that accepts a pre-processed argument list from user input
 #: and returns a boolean
-ArgListCommandFuncBoolReturn = Union[
-    Callable[['cmd2.Cmd', List[str]], bool],
-    Callable[[CommandSet, List[str]], bool],
-]
+ArgListCommandFuncBoolReturn = Callable[[CommandParent, List[str]], bool]
 #: Function signature for an Command Function that accepts a pre-processed argument list from user input
 #: and returns Nothing
-ArgListCommandFuncNoneReturn = Union[
-    Callable[['cmd2.Cmd', List[str]], None],
-    Callable[[CommandSet, List[str]], None],
-]
+ArgListCommandFuncNoneReturn = Callable[[CommandParent, List[str]], None]
 
 #: Aggregate of all accepted function signatures for Command Functions that accept a pre-processed argument list
-ArgListCommandFunc = Union[ArgListCommandFuncOptionalBoolReturn, ArgListCommandFuncBoolReturn, ArgListCommandFuncNoneReturn]
+ArgListCommandFunc = Union[
+    ArgListCommandFuncOptionalBoolReturn[CommandParent],
+    ArgListCommandFuncBoolReturn[CommandParent],
+    ArgListCommandFuncNoneReturn[CommandParent],
+]
 
 
 def with_argument_list(
-    func_arg: Optional[ArgListCommandFunc] = None,
+    func_arg: Optional[ArgListCommandFunc[CommandParent]] = None,
     *,
     preserve_quotes: bool = False,
-) -> Union[RawCommandFuncOptionalBoolReturn, Callable[[ArgListCommandFunc], RawCommandFuncOptionalBoolReturn]]:
+) -> Union[
+    RawCommandFuncOptionalBoolReturn[CommandParent],
+    Callable[[ArgListCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]],
+]:
     """
     A decorator to alter the arguments passed to a ``do_*`` method. Default
     passes a string of whatever the user typed. With this decorator, the
     decorated method will receive a list of arguments parsed from user input.
 
-    :param func_arg: Single-element positional argument list containing ``do_*`` method
+    :param func_arg: Single-element positional argument list containing ``doi_*`` method
                  this decorator is wrapping
     :param preserve_quotes: if ``True``, then argument quotes will not be stripped
     :return: function that gets passed a list of argument strings
@@ -161,7 +162,7 @@ def with_argument_list(
     """
     import functools
 
-    def arg_decorator(func: ArgListCommandFunc) -> RawCommandFuncOptionalBoolReturn:
+    def arg_decorator(func: ArgListCommandFunc[CommandParent]) -> RawCommandFuncOptionalBoolReturn[CommandParent]:
         """
         Decorator function that ingests an Argument List function and returns a raw command function.
         The returned function will process the raw input into an argument list to be passed to the wrapped function.
@@ -191,14 +192,11 @@ def with_argument_list(
         return cmd_wrapper
 
     if callable(func_arg):
-        # noinspection PyTypeChecker
         return arg_decorator(func_arg)
     else:
-        # noinspection PyTypeChecker
         return arg_decorator
 
 
-# noinspection PyProtectedMember
 def _set_parser_prog(parser: argparse.ArgumentParser, prog: str) -> None:
     """
     Recursively set prog attribute of a parser and all of its subparsers so that the root command
@@ -209,6 +207,7 @@ def _set_parser_prog(parser: argparse.ArgumentParser, prog: str) -> None:
     """
     # Set the prog value for this parser
     parser.prog = prog
+    req_args: List[str] = []
 
     # Set the prog value for the parser's subcommands
     for action in parser._actions:
@@ -233,52 +232,70 @@ def _set_parser_prog(parser: argparse.ArgumentParser, prog: str) -> None:
                 if subcmd_parser in processed_parsers:
                     continue
 
-                subcmd_prog = parser.prog + ' ' + subcmd_name
+                subcmd_prog = parser.prog
+                if req_args:
+                    subcmd_prog += " " + " ".join(req_args)
+                subcmd_prog += " " + subcmd_name
                 _set_parser_prog(subcmd_parser, subcmd_prog)
                 processed_parsers.append(subcmd_parser)
 
             # We can break since argparse only allows 1 group of subcommands per level
             break
 
+        # Need to save required args so they can be prepended to the subcommand usage
+        elif action.required:
+            req_args.append(action.dest)
+
 
 #: Function signature for a Command Function that uses an argparse.ArgumentParser to process user input
 #: and optionally returns a boolean
-ArgparseCommandFuncOptionalBoolReturn = Union[
-    Callable[['cmd2.Cmd', argparse.Namespace], Optional[bool]],
-    Callable[[CommandSet, argparse.Namespace], Optional[bool]],
-]
+ArgparseCommandFuncOptionalBoolReturn = Callable[[CommandParent, argparse.Namespace], Optional[bool]]
 #: Function signature for a Command Function that uses an argparse.ArgumentParser to process user input
 #: and returns a boolean
-ArgparseCommandFuncBoolReturn = Union[
-    Callable[['cmd2.Cmd', argparse.Namespace], bool],
-    Callable[[CommandSet, argparse.Namespace], bool],
-]
+ArgparseCommandFuncBoolReturn = Callable[[CommandParent, argparse.Namespace], bool]
 #: Function signature for an Command Function that uses an argparse.ArgumentParser to process user input
 #: and returns nothing
-ArgparseCommandFuncNoneReturn = Union[
-    Callable[['cmd2.Cmd', argparse.Namespace], None],
-    Callable[[CommandSet, argparse.Namespace], None],
-]
+ArgparseCommandFuncNoneReturn = Callable[[CommandParent, argparse.Namespace], None]
 
 #: Aggregate of all accepted function signatures for an argparse Command Function
 ArgparseCommandFunc = Union[
-    ArgparseCommandFuncOptionalBoolReturn,
-    ArgparseCommandFuncBoolReturn,
-    ArgparseCommandFuncNoneReturn,
+    ArgparseCommandFuncOptionalBoolReturn[CommandParent],
+    ArgparseCommandFuncBoolReturn[CommandParent],
+    ArgparseCommandFuncNoneReturn[CommandParent],
 ]
 
 
+@overload
 def with_argparser(
     parser: argparse.ArgumentParser,
     *,
     ns_provider: Optional[Callable[..., argparse.Namespace]] = None,
     preserve_quotes: bool = False,
     with_unknown_args: bool = False,
-) -> Callable[[ArgparseCommandFunc], RawCommandFuncOptionalBoolReturn]:
+) -> Callable[[ArgparseCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]]: ...  # pragma: no cover
+
+
+@overload
+def with_argparser(
+    parser: Callable[[], argparse.ArgumentParser],
+    *,
+    ns_provider: Optional[Callable[..., argparse.Namespace]] = None,
+    preserve_quotes: bool = False,
+    with_unknown_args: bool = False,
+) -> Callable[[ArgparseCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]]: ...  # pragma: no cover
+
+
+def with_argparser(
+    parser: Union[argparse.ArgumentParser, Callable[[], argparse.ArgumentParser]],
+    *,
+    ns_provider: Optional[Callable[..., argparse.Namespace]] = None,
+    preserve_quotes: bool = False,
+    with_unknown_args: bool = False,
+) -> Callable[[ArgparseCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]]:
     """A decorator to alter a cmd2 method to populate its ``args`` argument by parsing arguments
     with the given instance of argparse.ArgumentParser.
 
-    :param parser: unique instance of ArgumentParser
+    :param parser: unique instance of ArgumentParser or a callable that returns an ArgumentParser
     :param ns_provider: An optional function that accepts a cmd2.Cmd or cmd2.CommandSet object as an argument and returns an
                         argparse.Namespace. This is useful if the Namespace needs to be prepopulated with state data that
                         affects parsing.
@@ -320,7 +337,7 @@ def with_argparser(
     """
     import functools
 
-    def arg_decorator(func: ArgparseCommandFunc) -> RawCommandFuncOptionalBoolReturn:
+    def arg_decorator(func: ArgparseCommandFunc[CommandParent]) -> RawCommandFuncOptionalBoolReturn[CommandParent]:
         """
         Decorator function that ingests an Argparse Command Function and returns a raw command function.
         The returned function will process the raw input into an argparse Namespace to be passed to the wrapped function.
@@ -346,6 +363,10 @@ def with_argparser(
             statement, parsed_arglist = cmd2_app.statement_parser.get_command_arg_list(
                 command_name, statement_arg, preserve_quotes
             )
+            arg_parser = cmd2_app._command_parsers.get(command_name, None)
+            if arg_parser is None:
+                # This shouldn't be possible to reach
+                raise ValueError(f'No argument parser found for {command_name}')  # pragma: no cover
 
             if ns_provider is None:
                 namespace = None
@@ -359,9 +380,9 @@ def with_argparser(
             try:
                 new_args: Union[Tuple[argparse.Namespace], Tuple[argparse.Namespace, List[str]]]
                 if with_unknown_args:
-                    new_args = parser.parse_known_args(parsed_arglist, namespace)
+                    new_args = arg_parser.parse_known_args(parsed_arglist, namespace)
                 else:
-                    new_args = (parser.parse_args(parsed_arglist, namespace),)
+                    new_args = (arg_parser.parse_args(parsed_arglist, namespace),)
                 ns = new_args[0]
             except SystemExit:
                 raise Cmd2ArgparseError
@@ -381,16 +402,7 @@ def with_argparser(
                 args_list = _arg_swap(args, statement_arg, *new_args)
                 return func(*args_list, **kwargs)  # type: ignore[call-arg]
 
-        # argparser defaults the program name to sys.argv[0], but we want it to be the name of our command
         command_name = func.__name__[len(constants.COMMAND_FUNC_PREFIX) :]
-        _set_parser_prog(parser, command_name)
-
-        # If the description has not been set, then use the method docstring if one exists
-        if parser.description is None and func.__doc__:
-            parser.description = strip_doc_annotations(func.__doc__)
-
-        # Set the command's help text as argparser.description (which can be None)
-        cmd_wrapper.__doc__ = parser.description
 
         # Set some custom attributes for this command
         setattr(cmd_wrapper, constants.CMD_ATTR_ARGPARSER, parser)
@@ -398,10 +410,10 @@ def with_argparser(
 
         return cmd_wrapper
 
-    # noinspection PyTypeChecker
     return arg_decorator
 
 
+@overload
 def as_subcommand_to(
     command: str,
     subcommand: str,
@@ -409,7 +421,28 @@ def as_subcommand_to(
     *,
     help: Optional[str] = None,
     aliases: Optional[List[str]] = None,
-) -> Callable[[ArgparseCommandFunc], ArgparseCommandFunc]:
+) -> Callable[[ArgparseCommandFunc[CommandParent]], ArgparseCommandFunc[CommandParent]]: ...  # pragma: no cover
+
+
+@overload
+def as_subcommand_to(
+    command: str,
+    subcommand: str,
+    parser: Callable[[], argparse.ArgumentParser],
+    *,
+    help: Optional[str] = None,
+    aliases: Optional[List[str]] = None,
+) -> Callable[[ArgparseCommandFunc[CommandParent]], ArgparseCommandFunc[CommandParent]]: ...  # pragma: no cover
+
+
+def as_subcommand_to(
+    command: str,
+    subcommand: str,
+    parser: Union[argparse.ArgumentParser, Callable[[], argparse.ArgumentParser]],
+    *,
+    help: Optional[str] = None,
+    aliases: Optional[List[str]] = None,
+) -> Callable[[ArgparseCommandFunc[CommandParent]], ArgparseCommandFunc[CommandParent]]:
     """
     Tag this method as a subcommand to an existing argparse decorated command.
 
@@ -423,13 +456,7 @@ def as_subcommand_to(
     :return: Wrapper function that can receive an argparse.Namespace
     """
 
-    def arg_decorator(func: ArgparseCommandFunc) -> ArgparseCommandFunc:
-        _set_parser_prog(parser, command + ' ' + subcommand)
-
-        # If the description has not been set, then use the method docstring if one exists
-        if parser.description is None and func.__doc__:
-            parser.description = func.__doc__
-
+    def arg_decorator(func: ArgparseCommandFunc[CommandParent]) -> ArgparseCommandFunc[CommandParent]:
         # Set some custom attributes for this command
         setattr(func, constants.SUBCMD_ATTR_COMMAND, command)
         setattr(func, constants.CMD_ATTR_ARGPARSER, parser)
@@ -446,5 +473,4 @@ def as_subcommand_to(
 
         return func
 
-    # noinspection PyTypeChecker
     return arg_decorator

cmd2/exceptions.py

@@ -61,7 +61,6 @@ class CompletionError(Exception):
         """
         self.apply_style = apply_style
 
-        # noinspection PyArgumentList
         super().__init__(*args)
 
 

cmd2/history.py

@@ -8,6 +8,9 @@ import re
 from collections import (
     OrderedDict,
 )
+from dataclasses import (
+    dataclass,
+)
 from typing import (
     Any,
     Callable,
@@ -19,17 +22,54 @@ from typing import (
     overload,
 )
 
-import attr
-
 from . import (
     utils,
 )
 from .parsing import (
     Statement,
+    shlex_split,
 )
 
 
-@attr.s(auto_attribs=True, frozen=True)
+def single_line_format(statement: Statement) -> str:
+    """
+    Format a command line to display on a single line.
+
+    Spaces and newlines in quotes are preserved so those strings will span multiple lines.
+
+    :param statement: Statement being formatted.
+    :return: formatted command line
+    """
+    if not statement.raw:
+        return ""
+
+    lines = statement.raw.splitlines()
+    formatted_command = lines[0]
+
+    # Append any remaining lines to the command.
+    for line in lines[1:]:
+        try:
+            shlex_split(formatted_command)
+        except ValueError:
+            # We are in quotes, so restore the newline.
+            separator = "\n"
+        else:
+            # Don't add a space before line if one already exists or if it begins with the terminator.
+            if (
+                formatted_command.endswith(" ")
+                or line.startswith(" ")
+                or (statement.terminator and line.startswith(statement.terminator))
+            ):
+                separator = ""
+            else:
+                separator = " "
+
+        formatted_command += separator + line
+
+    return formatted_command
+
+
+@dataclass(frozen=True)
 class HistoryItem:
     """Class used to represent one command in the history list"""
 
@@ -39,10 +79,10 @@ class HistoryItem:
     # Used in JSON dictionaries
     _statement_field = 'statement'
 
-    statement: Statement = attr.ib(default=None, validator=attr.validators.instance_of(Statement))
+    statement: Statement
 
     def __str__(self) -> str:
-        """A convenient human readable representation of the history item"""
+        """A convenient human-readable representation of the history item"""
         return self.statement.raw
 
     @property
@@ -84,15 +124,7 @@ class HistoryItem:
             if expanded:
                 ret_str = self.expanded
             else:
-                ret_str = self.raw.rstrip()
-
-                # In non-verbose mode, display raw multiline commands on 1 line
-                if self.statement.multiline_command:
-                    # This is an approximation and not meant to be a perfect piecing together of lines.
-                    # All newlines will be converted to spaces, including the ones in quoted strings that
-                    # are considered literals. Also if the final line starts with a terminator, then the
-                    # terminator will have an extra space before it in the 1 line version.
-                    ret_str = ret_str.replace('\n', ' ')
+                ret_str = single_line_format(self.statement).rstrip()
 
             # Display a numbered list if not writing to a script
             if not script:
@@ -144,7 +176,6 @@ class History(List[HistoryItem]):
         """Start a new session, thereby setting the next index as the first index in the new session."""
         self.session_start_index = len(self)
 
-    # noinspection PyMethodMayBeStatic
     def _zero_based_index(self, onebased: Union[int, str]) -> int:
         """Convert a one-based index to a zero-based index."""
         result = int(onebased)
@@ -153,12 +184,10 @@ class History(List[HistoryItem]):
         return result
 
     @overload
-    def append(self, new: HistoryItem) -> None:
-        ...  # pragma: no cover
+    def append(self, new: HistoryItem) -> None: ...  # pragma: no cover
 
     @overload
-    def append(self, new: Statement) -> None:
-        ...  # pragma: no cover
+    def append(self, new: Statement) -> None: ...  # pragma: no cover
 
     def append(self, new: Union[Statement, HistoryItem]) -> None:
         """Append a new statement to the end of the History list.

cmd2/parsing.py

@@ -4,6 +4,10 @@
 
 import re
 import shlex
+from dataclasses import (
+    dataclass,
+    field,
+)
 from typing import (
     Any,
     Dict,
@@ -14,8 +18,6 @@ from typing import (
     Union,
 )
 
-import attr
-
 from . import (
     constants,
     utils,
@@ -36,7 +38,7 @@ def shlex_split(str_to_split: str) -> List[str]:
     return shlex.split(str_to_split, comments=False, posix=False)
 
 
-@attr.s(auto_attribs=True, frozen=True)
+@dataclass(frozen=True)
 class MacroArg:
     """
     Information used to replace or unescape arguments in a macro value when the macro is resolved
@@ -45,15 +47,15 @@ class MacroArg:
     """
 
     # The starting index of this argument in the macro value
-    start_index: int = attr.ib(validator=attr.validators.instance_of(int))
+    start_index: int
 
     # The number string that appears between the braces
     # This is a string instead of an int because we support unicode digits and must be able
     # to reproduce this string later
-    number_str: str = attr.ib(validator=attr.validators.instance_of(str))
+    number_str: str
 
     # Tells if this argument is escaped and therefore needs to be unescaped
-    is_escaped: bool = attr.ib(validator=attr.validators.instance_of(bool))
+    is_escaped: bool
 
     # Pattern used to find normal argument
     # Digits surrounded by exactly 1 brace on a side and 1 or more braces on the opposite side
@@ -69,24 +71,24 @@ class MacroArg:
     digit_pattern = re.compile(r'\d+')
 
 
-@attr.s(auto_attribs=True, frozen=True)
+@dataclass(frozen=True)
 class Macro:
     """Defines a cmd2 macro"""
 
     # Name of the macro
-    name: str = attr.ib(validator=attr.validators.instance_of(str))
+    name: str
 
     # The string the macro resolves to
-    value: str = attr.ib(validator=attr.validators.instance_of(str))
+    value: str
 
     # The minimum number of args the user has to pass to this macro
-    minimum_arg_count: int = attr.ib(validator=attr.validators.instance_of(int))
+    minimum_arg_count: int
 
     # Used to fill in argument placeholders in the macro
-    arg_list: List[MacroArg] = attr.ib(default=attr.Factory(list), validator=attr.validators.instance_of(list))
+    arg_list: List[MacroArg] = field(default_factory=list)
 
 
-@attr.s(auto_attribs=True, frozen=True)
+@dataclass(frozen=True)
 class Statement(str):  # type: ignore[override]
     """String subclass with additional attributes to store the results of parsing.
 
@@ -118,34 +120,34 @@ class Statement(str):  # type: ignore[override]
     """
 
     # the arguments, but not the command, nor the output redirection clauses.
-    args: str = attr.ib(default='', validator=attr.validators.instance_of(str))
+    args: str = ''
 
     # string containing exactly what we input by the user
-    raw: str = attr.ib(default='', validator=attr.validators.instance_of(str))
+    raw: str = ''
 
     # the command, i.e. the first whitespace delimited word
-    command: str = attr.ib(default='', validator=attr.validators.instance_of(str))
+    command: str = ''
 
     # list of arguments to the command, not including any output redirection or terminators; quoted args remain quoted
-    arg_list: List[str] = attr.ib(default=attr.Factory(list), validator=attr.validators.instance_of(list))
+    arg_list: List[str] = field(default_factory=list)
 
     # if the command is a multiline command, the name of the command, otherwise empty
-    multiline_command: str = attr.ib(default='', validator=attr.validators.instance_of(str))
+    multiline_command: str = ''
 
     # the character which terminated the multiline command, if there was one
-    terminator: str = attr.ib(default='', validator=attr.validators.instance_of(str))
+    terminator: str = ''
 
     # characters appearing after the terminator but before output redirection, if any
-    suffix: str = attr.ib(default='', validator=attr.validators.instance_of(str))
+    suffix: str = ''
 
     # if output was piped to a shell command, the shell command as a string
-    pipe_to: str = attr.ib(default='', validator=attr.validators.instance_of(str))
+    pipe_to: str = ''
 
     # if output was redirected, the redirection token, i.e. '>>'
-    output: str = attr.ib(default='', validator=attr.validators.instance_of(str))
+    output: str = ''
 
     # if output was redirected, the destination file token (quotes preserved)
-    output_to: str = attr.ib(default='', validator=attr.validators.instance_of(str))
+    output_to: str = ''
 
     # Used in JSON dictionaries
     _args_field = 'args'
@@ -156,7 +158,7 @@ class Statement(str):  # type: ignore[override]
         We must override __new__ because we are subclassing `str` which is
         immutable and takes a different number of arguments as Statement.
 
-        NOTE:  attrs takes care of initializing other members in the __init__ it
+        NOTE:  @dataclass takes care of initializing other members in the __init__ it
         generates.
         """
         stmt = super().__new__(cls, value)
@@ -348,7 +350,7 @@ class StatementParser:
             return False, 'cannot start with the comment character'
 
         if not is_subcommand:
-            for (shortcut, _) in self.shortcuts:
+            for shortcut, _ in self.shortcuts:
                 if word.startswith(shortcut):
                     # Build an error string with all shortcuts listed
                     errmsg = 'cannot start with a shortcut: '
@@ -481,7 +483,6 @@ class StatementParser:
 
         # Check if output should be piped to a shell command
         if pipe_index < redir_index and pipe_index < append_index:
-
             # Get the tokens for the pipe command and expand ~ where needed
             pipe_to_tokens = tokens[pipe_index + 1 :]
             utils.expand_user_in_tokens(pipe_to_tokens)
@@ -580,8 +581,15 @@ class StatementParser:
 
             # take everything from the end of the first match group to
             # the end of the line as the arguments (stripping leading
-            # and trailing spaces)
-            args = line[match.end(1) :].strip()
+            # and unquoted trailing whitespace)
+            args = line[match.end(1) :].lstrip()
+            try:
+                shlex_split(args)
+            except ValueError:
+                # Unclosed quote. Leave trailing whitespace.
+                pass
+            else:
+                args = args.rstrip()
             # if the command is empty that means the input was either empty
             # or something weird like '>'. args should be empty if we couldn't
             # parse a command
@@ -656,7 +664,7 @@ class StatementParser:
                     keep_expanding = bool(remaining_aliases)
 
         # expand shortcuts
-        for (shortcut, expansion) in self.shortcuts:
+        for shortcut, expansion in self.shortcuts:
             if line.startswith(shortcut):
                 # If the next character after the shortcut isn't a space, then insert one
                 shortcut_len = len(shortcut)
@@ -701,7 +709,6 @@ class StatementParser:
         punctuated_tokens = []
 
         for cur_initial_token in tokens:
-
             # Save tokens up to 1 character in length or quoted tokens. No need to parse these.
             if len(cur_initial_token) <= 1 or cur_initial_token[0] in constants.QUOTES:
                 punctuated_tokens.append(cur_initial_token)
@@ -716,7 +723,6 @@ class StatementParser:
 
             while True:
                 if cur_char not in punctuation:
-
                     # Keep appending to new_token until we hit a punctuation char
                     while cur_char not in punctuation:
                         new_token += cur_char