0.9.13 (June 14, 2019)

• Bug Fixes
  • Fixed issue where the wrong terminator was being appended by Statement.expanded_command_line()
  • Fixed issue where aliases and macros could not contain terminator characters in their values
  • History now shows what was typed for macros and not the resolved value by default. This is consistent with the behavior of aliases. Use the expanded or verbose arguments to history to see the resolved value for the macro.
  • Fixed parsing issue in case where output redirection appears before a pipe. In that case, the pipe was given precedence even though it appeared later in the command.
  • Fixed issue where quotes around redirection file paths were being lost in Statement.expanded_command_line()
  • Fixed a bug in how line numbers were calculated for transcript testing
  • Fixed issue where _cmdloop() suppressed exceptions by returning from within its finally code
  • Fixed UnsupportedOperation on fileno error when a shell command was one of the commands run while generating a transcript
  • Fixed bug where history was displaying expanded multiline commands when -x was not specified
• Enhancements
  • Added capability to chain pipe commands and redirect their output (e.g. !ls -l | grep user | wc -l > out.txt)
  • pyscript limits a command's stdout capture to the same period that redirection does. Therefore output from a command's postparsing and finalization hooks isn't saved in the StdSim object.
  • StdSim.buffer.write() now flushes when the wrapped stream uses line buffering and the bytes being written contain a newline or carriage return. This helps when pyscript is echoing the output of a shell command since the output will print at the same frequency as when the command is run in a terminal.
  • ACArgumentParser no longer prints complete help text when a parsing error occurs since long help messages scroll the actual error message off the screen.
  • Exceptions occurring in tab completion functions are now printed to stderr before returning control back to readline. This makes debugging a lot easier since readline suppresses these exceptions.
  • Added support for custom Namespaces in the argparse decorators. See description of ns_provider argument for more information.
  • Transcript testing now sets the exit_code returned from cmdloop based on Success/Failure
  • The history of entered commands previously was saved using the readline persistence mechanism, and only persisted if you had readline installed. Now history is persisted independent of readline; user input from previous invocations of cmd2 based apps now shows in the history command.
  • Text scripts now run immediately instead of adding their commands to cmdqueue. This allows easy capture of the entire script's output.
  • Added member to CommandResult called stop which is the return value of onecmd_plus_hooks after it runs the given command line.
• Breaking changes
  • Replaced unquote_redirection_tokens() with unquote_specific_tokens(). This was to support the fix that allows terminators in alias and macro values.
  • Changed Statement.pipe_to to a string instead of a list
  • preserve_quotes is now a keyword-only argument in the argparse decorators
  • Refactored so that cmd2.Cmd.cmdloop() returns the exit_code instead of a call to sys.exit() It is now application developer's responsibility to treat the return value from cmdloop() accordingly
  • Only valid commands are persistent in history between invocations of cmd2 based apps. Previously all user input was persistent in history. If readline is installed, the history available with the up and down arrow keys (readline history) may not match that shown in the history command, because history only tracks valid input, while readline history captures all input.
  • History is now persisted in a binary format, not plain text format. Previous history files are destroyed on first launch of a cmd2 based app of version 0.9.13 or higher.
  • HistoryItem class is no longer a subclass of str. If you are directly accessing the .history attribute of a cmd2 based app, you will need to update your code to use .history.get(1).statement.raw instead.
  • Removed internally used eos command that was used to keep track of when a text script's commands ended
  • Removed cmd2 member called _STOP_AND_EXIT since it was just a boolean value that should always be True
  • Removed cmd2 member called _should_quit since PyscriptBridge now handles this logic
  • Removed support for cmd.cmdqueue
  • allow_cli_args is now an argument to init instead of a cmd2 class member
• Python 3.4 EOL notice
  • Python 3.4 reached its end of life on March 18, 2019
  • This is the last release of cmd2 which will support Python 3.4

0.9.12 (April 22, 2019) 🌍

• Bug Fixes
  • Fixed a bug in how redirection and piping worked inside py or pyscript commands
  • Fixed bug in async_alert where it didn't account for prompts that contained newline characters
  • Fixed path completion case when CWD is just a slash. Relative path matches were incorrectly prepended with a slash.
• Enhancements
  • Added ability to include command name placeholders in the message printed when trying to run a disabled command.
    • See docstring for disable_command() or disable_category() for more details.
  • Added instance attributes to customize error messages without having to override methods. Theses messages can also be colored.
    • help_error - the error that prints when no help information can be found
    • default_error - the error that prints when a non-existent command is run
  • The with_argparser decorators now add the Statement object created when parsing the command line to the argparse.Namespace object they pass to the do_* methods. It is stored in an attribute called __statement__. This can be useful if a command function needs to know the command line for things like logging.
  • Added a -t option to the load command for automatically generating a transcript based on a script file
  • When in a pyscript, the stdout and stderr streams of shell commands and processes being piped to are now captured and included in the CommandResult structure.
• Potentially breaking changes
  • The following commands now write to stderr instead of stdout when printing an error. This will make catching errors easier in pyscript.
    • do_help() - when no help information can be found
    • default() - in all cases since this is called when an invalid command name is run
    • _report_disabled_command_usage() - in all cases since this is called when a disabled command is run
  • Removed *** from beginning of error messages printed by do_help() and default()
  • Significantly refactored cmd.Cmd class so that all class attributes got converted to instance attributes, also:
    • Added allow_redirection, terminators, multiline_commands, and shortcuts as optional arguments to cmd2.Cmd.__init__()
    • A few instance attributes were moved inside StatementParser and properties were created for accessing them
  • self.pipe_proc is now called self.cur_pipe_proc_reader and is a ProcReader class.
  • Shell commands and commands being piped to while in a pyscript will function as if their output is going to a pipe and not a tty. This was necessary to be able to capture their output.
  • Removed reserved_words class attribute due to lack of use
  • Removed keywords instance attribute due to lack of use

0.9.11 (March 13, 2019)

• Bug Fixes
  • Fixed bug in how history command deals with multiline commands when output to a script
  • Fixed a bug when the with_argument_list decorator is called with the optional preserve_quotes argument
  • Fix bug in perror() where it would try to print an exception Traceback even if none existed
• Enhancements
  • Improvements to the history command
    • Simplified the display format and made it more similar to bash
    • Added -x, --expanded flag
      • output expanded commands instead of entered command (expands aliases, macros, and shortcuts)
    • Added -v, --verbose flag
      • display history and include expanded commands if they differ from the typed command
    • Added support for negative indices
  • Added matches_sort_key to override the default way tab completion matches are sorted
  • Added StdSim.pause_storage member which when True will cause StdSim to not save the output sent to it. See documentation for CommandResult in pyscript_bridge.py for reasons pausing the storage can be useful.
  • Added ability to disable/enable individual commands and entire categories of commands. When a command is disabled, it will not show up in the help menu or tab complete. If a user tries to run the command or call help on it, a command-specific message supplied by the developer will be printed. The following commands were added to support this feature.
    • enable_command()
    • enable_category()
    • disable_command()
    • disable_category()
• Potentially breaking changes
  • Made cmd2_app a positional and required argument of AutoCompleter since certain functionality now requires that it can't be None.
  • AutoCompleter no longer assumes CompletionItem results are sorted. Therefore you should follow the cmd2 convention of setting self.matches_sorted to True before returning the results if you have already sorted the CompletionItem list. Otherwise it will be sorted using self.matches_sort_key.
  • Removed support for bash completion since this feature had slow performance. Also it relied on AutoCompleter which has since developed a dependency on cmd2 methods.
  • Removed ability to call commands in pyscript as if they were functions (e.g app.help()) in favor of only supporting one pyscript interface. This simplifies future maintenance.
  • No longer supporting C-style comments. Hash (#) is the only valid comment marker.
  • No longer supporting comments embedded in a command. Only command line input where the first non-whitespace character is a # will be treated as a comment. This means any # character appearing later in the command will be treated as a literal. The same applies to a # in the middle of a multiline command, even if it is the first character on a line.
    • # this is a comment
    • this # is not a comment

0.9.10 (February 22, 2019)

0.9.10 (February 22, 2019)

• Bug Fixes
  • Fixed unit test that hangs on Windows

0.9.9 (February 21, 2019)

• Bug Fixes
  • Fixed bug where the set command was not tab completing from the current settable dictionary.
• Enhancements
  • Changed edit command to use do_shell() instead of calling os.system()

0.9.8 (February 06, 2019)

• Bug Fixes
  • Fixed issue with echoing strings in StdSim. Because they were being sent to a binary buffer, line buffering was being ignored.
• Enhancements
  • Made quit() and exit() functions available to scripts run with pyscript. This allows those scripts to exit back to the console's prompt instead of exiting the whole application.

0.9.7 (January 08, 2019)

• Bug Fixes
  • Fixed bug when user chooses a zero or negative index when calling Cmd.select()
  • Restored behavior where cmd_echo always starts as False in a py script. This was broken in 0.9.5.
• Enhancements
  • cmdloop now only attempts to register a custom signal handler for SIGINT if running in the main thread
  • commands run as a result of default_to_shell being True now run via do_shell() and are saved
    to history.
  • Added more tab completion to pyscript command.
• Deletions (potentially breaking changes)
  • Deleted Cmd.colorize() and Cmd._colorcodes which were deprecated in 0.9.5
  • Replaced dir_exe_only and dir_only flags in path_complete with optional path_filter function
    that is used to filter paths out of completion results.
  • perror() no longer prepends "ERROR: " to the error message being printed

0.9.6 (October 13, 2018)

• Bug Fixes
  • Fixed bug introduced in 0.9.5 caused by backing up and restoring self.prompt in pseudo_raw_input.
    As part of this fix, continuation prompts will not be redrawn with async_update_prompt or async_alert.
• Enhancements
  • All platforms now depend on wcwidth to assist with asynchronous alerts.
  • Macros now accept extra arguments when called. These will be tacked onto the resolved command.
  • All cmd2 commands run via py now go through onecmd_plus_hooks.

0.9.5 (October 11, 2018)

• Bug Fixes
  • Fixed bug where get_all_commands could return non-callable attributes
  • Fixed bug where alias command was dropping quotes around arguments
  • Fixed bug where running help on argparse commands didn't work if they didn't support -h
  • Fixed transcript testing bug where last command in transcript has no expected output
  • Fixed bugs with how AutoCompleter and ArgparseFunctor handle argparse
    arguments with nargs=argparse.REMAINDER. Tab completion now correctly
    matches how argparse will parse the values. Command strings generated by
    ArgparseFunctor should now be compliant with how argparse expects
    REMAINDER arguments to be ordered.
  • Fixed bugs with how AutoCompleter handles flag prefixes. It is no
    longer hard-coded to use '-' and will check against the prefix_chars in
    the argparse object. Also, single-character tokens that happen to be a
    prefix char are not treated as flags by argparse and AutoCompleter now
    matches that behavior.
  • Fixed bug where AutoCompleter was not distinguishing between a negative number and a flag
  • Fixed bug where AutoCompleter did not handle -- the same way argparse does (all args after -- are non-options)
• Enhancements
  • Added exit_code attribute of cmd2.Cmd class
    • Enables applications to return a non-zero exit code when exiting from cmdloop
  • ACHelpFormatter now inherits from argparse.RawTextHelpFormatter to make it easier
    for formatting help/description text
  • Aliases are now sorted alphabetically
  • The set command now tab-completes settable parameter names
  • Added async_alert, async_update_prompt, and set_window_title functions
    • These allow you to provide feedback to the user in an asychronous fashion, meaning alerts can
      display when the user is still entering text at the prompt. See async_printing.py
      for an example.
  • Cross-platform colored output support
    • colorama gets initialized properly in Cmd.__init()
    • The Cmd.colors setting is no longer platform dependent and now has three values:
      • Terminal (default) - output methods do not strip any ANSI escape sequences when output is a terminal, but
        if the output is a pipe or a file the escape sequences are stripped
      • Always - output methods never strip ANSI escape sequences, regardless of the output destination
      • Never - output methods strip all ANSI escape sequences
  • Added macro command to create macros, which are similar to aliases, but can take arguments when called
  • All cmd2 command functions have been converted to use argparse.
  • Renamed argparse_example.py to decorator_example.py to help clarify its intent
• Deprecations
  • Deprecated the built-in cmd2 support for colors including Cmd.colorize() and Cmd._colorcodes
• Deletions (potentially breaking changes)
  • The preparse, postparsing_precmd, and postparsing_postcmd methods deprecated in the previous release
    have been deleted
    • The new application lifecycle hook system allows for registration of callbacks to be called at various points
      in the lifecycle and is more powerful and flexible than the previous system
  • alias is now a command with sub-commands to create, list, and delete aliases. Therefore its syntax
    has changed. All current alias commands in startup scripts or transcripts will break with this release.
  • unalias was deleted since alias delete replaced it

0.9.4 (August 21, 2018)

• Bug Fixes
  • Fixed bug where preparse was not getting called
  • Fixed bug in parsing of multiline commands where matching quote is on another line
• Enhancements
  • Improved implementation of lifecycle hooks to support a plugin
    framework, see docs/hooks.rst for details.
  • New dependency on attrs third party module
  • Added matches_sorted member to support custom sorting of tab-completion matches
  • Added tab_autocomp_dynamic.py example
    • Demonstrates updating the argparse object during init instead of during class construction
• Deprecations
  • Deprecated the following hook methods, see hooks.rst for full details:
    • cmd2.Cmd.preparse() - equivalent functionality available
      via cmd2.Cmd.register_postparsing_hook()
    • cmd2.Cmd.postparsing_precmd() - equivalent functionality available
      via cmd2.Cmd.register_postparsing_hook()
    • cmd2.Cmd.postparsing_postcmd() - equivalent functionality available
      via cmd2.Cmd.register_postcmd_hook()