Continuing to update documentation

Author: tleonhardt

docs/features/history.md

@@ -14,9 +14,9 @@ Each time a command is executed (this gets complex, see
 [cmd2.Statement][] is appended to `cmd2.Cmd.history`.
 
 `cmd2` adds the option of making this history persistent via optional arguments to
-`cmd2.Cmd.__init__`. If you pass a filename in the `persistent_history_file` argument, the contents
-of `cmd2.Cmd.history` will be written as compressed JSON to that history file. We chose this format
-instead of plain text to preserve the complete `cmd2.Statement` object for each command.
+[cmd2.Cmd.\_\_init\_\_][]. If you pass a filename in the `persistent_history_file` argument, the
+contents of `cmd2.Cmd.history` will be written as compressed JSON to that history file. We chose
+this format instead of plain text to preserve the complete `cmd2.Statement` object for each command.
 
 !!! note
 
@@ -25,21 +25,22 @@ instead of plain text to preserve the complete `cmd2.Statement` object for each
     However, this design choice causes an inconsistency between the `readline` history and the `cmd2` history when you enter an invalid command: it is saved to the `readline` history, but not to the `cmd2` history.
 
 The `cmd2.Cmd.history` attribute, the `cmd2.history.History` class, and the
-`cmd2.history.HistoryItem` class are all part of the public API for `cmd2.Cmd`. You could use these
-classes to implement write your own `history` command (see below for documentation on how the
-included `history` command works).
+[cmd2.history.HistoryItem][] class are all part of the public API for `cmd2.Cmd`. You could use
+these classes to implement your own `history` command (see below for documentation on how the
+built-in `history` command works).
 
 ## For Users
 
-You can use the up and down arrow keys to move through the history of previously entered commands.
+You can use the :arrow_up: up and :arrow_down: down arrow keys to move through the history of
+previously entered commands.
 
 If the `readline` module is installed, you can press `Control-p` to move to the previously entered
 command, and `Control-n` to move to the next command. You can also search through the command
 history using `Control-r`.
 
-Eric Johnson hosts a nice [readline cheat sheet](http://readline.kablamo.org/emacs.html), or you can
-dig into the [GNU Readline User Manual](http://man7.org/linux/man-pages/man3/readline.3.html) for
-all the details, including instructions for customizing the key bindings.
+You can refer to the [readline cheat sheet](http://readline.kablamo.org/emacs.html) or you can dig
+into the [GNU Readline User Manual](http://man7.org/linux/man-pages/man3/readline.3.html) for all
+the details, including instructions for customizing the key bindings.
 
 `cmd2` makes a third type of history access available with the `history` command. Each time the user
 enters a command, `cmd2` saves the input. The `history` command lets you do interesting things with

docs/features/hooks.md

@@ -54,22 +54,23 @@ called, the `cmd2.Cmd.postloop` method is called.
 Preloop and postloop hook methods are not passed any parameters and any return value is ignored.
 
 The approach of registering hooks instead of overriding methods allows multiple hooks to be called
-before the command loop begins or ends. Plugin authors should review [Hooks](./hooks.md) for best
-practices writing hooks.
+before the command loop begins or ends. Plugin authors should review this page carefully in full for
+best practices writing hooks.
 
 ## Application Lifecycle Attributes
 
-There are numerous attributes on `cmd2.Cmd` which affect application behavior upon entering or
+There are numerous attributes on [cmd2.Cmd][] which affect application behavior upon entering or
 during the command loop:
 
-- `cmd2.Cmd.intro` - if provided this serves as the intro banner printed once at start of
+- [cmd2.Cmd.intro][] - if provided this serves as the intro banner printed once at start of
   application, after `cmd2.Cmd.preloop` is called
-- `cmd2.Cmd.prompt` - see [Prompt](./prompt.md) for more information
-- `cmd2.Cmd.continuation_prompt` - The prompt issued to solicit input for the 2nd and subsequent
+- [cmd2.Cmd.prompt][] - see [Prompt](./prompt.md) for more information
+- [cmd2.Cmd.continuation_prompt][] - The prompt issued to solicit input for the 2nd and subsequent
   lines of a [Multiline Command](./multiline_commands.md)
-- `cmd2.Cmd.echo` - if `True` write the prompt and the command into the output stream
+- [cmd2.Cmd.echo][] - if `True` write the prompt and the command into the output stream
 
-In addition, several arguments to `cmd2.Cmd.__init__` also affect the command loop behavior:
+In addition, several arguments to [cmd2.Cmd.\_\_init\_\_][cmd2.Cmd.__init__] also affect the command
+loop behavior:
 
 - `allow_cli_args` - allows commands to be specified on the operating system command line which are
   executed before the command processing loop begins
@@ -84,25 +85,25 @@ application exits:
 
 1. Output the prompt
 1. Accept user input
-1. Parse user input into a `cmd2.Statement` object
-1. Call methods registered with `cmd2.Cmd.register_postparsing_hook()`
+1. Parse user input into a [cmd2.Statement][] object
+1. Call methods registered with [cmd2.Cmd.register_postparsing_hook][]
 1. Redirect output, if user asked for it and it's allowed
 1. Start timer
-1. Call methods registered with `cmd2.Cmd.register_precmd_hook`
-1. Call `cmd2.Cmd.precmd` - for backwards compatibility with `cmd.Cmd`
+1. Call methods registered with [cmd2.Cmd.register_precmd_hook][]
+1. Call [cmd2.Cmd.precmd][] - for backwards compatibility with `cmd.Cmd`
 1. Add statement to [History](./history.md)
 1. Call `do_command` method
-1. Call methods registered with `cmd2.Cmd.register_postcmd_hook()`
-1. Call `cmd2.Cmd.postcmd` - for backwards compatibility with `cmd.Cmd`
+1. Call methods registered with [cmd2.Cmd.register_postcmd_hook][]
+1. Call [cmd2.Cmd.postcmd][] - for backwards compatibility with `cmd.Cmd`
 1. Stop timer and display the elapsed time
 1. Stop redirecting output if it was redirected
-1. Call methods registered with `cmd2.Cmd.register_cmdfinalization_hook()`
+1. Call methods registered with [cmd2.Cmd.register_cmdfinalization_hook][]
 
 By registering hook methods, multiple steps allow you to run code during, and control the flow of
 the command processing loop. Be aware that plugins also utilize these hooks, so there may be code
-running that is not part of your application. Methods registered for a hook are called in the order
-they were registered. You can register a function more than once, and it will be called each time it
-was registered.
+running that is not directly part of your application code. Methods registered for a hook are called
+in the order they were registered. You can register a function more than once, and it will be called
+each time it was registered.
 
 Postparsing, precommand, and postcommand hook methods share some common ways to influence the
 command processing loop.
@@ -146,7 +147,7 @@ class App(cmd2.Cmd):
 a `TypeError` if it has the wrong number of parameters. It will also raise a `TypeError` if the
 passed parameter and return value are not annotated as `PostparsingData`.
 
-The hook method will be passed one parameter, a `cmd2.plugin.PostparsingData` object which we will
+The hook method will be passed one parameter, a [cmd2.plugin.PostparsingData][] object which we will
 refer to as `params`. `params` contains two attributes. `params.statement` is a `cmd2.Statement`
 object which describes the parsed user input. There are many useful attributes in the
 `cmd2.Statement` object, including `.raw` which contains exactly what the user typed. `params.stop`
@@ -162,10 +163,10 @@ To modify the user input, you create a new `cmd2.Statement` object and return it
 be dragons. Instead, use the various attributes in a `cmd2.Statement` object to construct a new
 string, and then parse that string to create a new `cmd2.Statement` object.
 
-`cmd2.Cmd` uses an instance of `cmd2.parsing.StatementParser` to parse user input. This instance has
-been configured with the proper command terminators, multiline commands, and other parsing related
-settings. This instance is available as the `cmd2.Cmd.statement_parser` attribute. Here's a simple
-example which shows the proper technique:
+`cmd2.Cmd` uses an instance of [cmd2.parsing.StatementParser][] to parse user input. This instance
+has been configured with the proper command terminators, multiline commands, and other parsing
+related settings. This instance is available as the `cmd2.Cmd.statement_parser` attribute. Here's a
+simple example which shows the proper technique:
 
 ```py
 def myhookmethod(self, params: cmd2.plugin.PostparsingData) -> cmd2.plugin.PostparsingData:
@@ -211,8 +212,8 @@ parameters and return value are not annotated as `PrecommandData`.
 You may choose to modify the user input by creating a new `cmd2.Statement` with different properties
 (see above). If you do so, assign your new `cmd2.Statement` object to `data.statement`.
 
-The precommand hook must return a `cmd2.plugin.PrecommandData` object. You don't have to create this
-object from scratch, you can just return the one passed into the hook.
+The precommand hook must return a [cmd2.plugin.PrecommandData][] object. You don't have to create
+this object from scratch, you can just return the one passed into the hook.
 
 After all registered precommand hooks have been called, `cmd2.Cmd.precmd` will be called. To retain
 full backward compatibility with `cmd.Cmd`, this method is passed a `cmd2.Statement`, not a
@@ -236,7 +237,7 @@ class App(cmd2.Cmd):
         return data
 ```
 
-Your hook will be passed a `cmd2.plugin.PostcommandData` object, which has a
+Your hook will be passed a [cmd2.plugin.PostcommandData][] object, which has a
 `cmd2.plugin.PostcommandData.statement` attribute that describes the command which was executed. If
 your postcommand hook method gets called, you are guaranteed that the command method was called, and
 that it didn't raise an exception.
@@ -263,8 +264,8 @@ otherwise.
 To purposefully and silently skip postcommand hooks, commands can raise any of the following
 exceptions.
 
-- `cmd2.exceptions.SkipPostcommandHooks`
-- `cmd2.exceptions.Cmd2ArgparseError`
+- [cmd2.exceptions.SkipPostcommandHooks][]
+- [cmd2.exceptions.Cmd2ArgparseError][]
 
 ## Command Finalization Hooks
 
@@ -282,7 +283,7 @@ class App(cmd2.Cmd):
 ```
 
 Command Finalization hooks must check whether the `cmd2.plugin.CommandFinalizationData.statement`
-attribute of the passed `cmd2.plugin.CommandFinalizationData` object contains a value. There are
+attribute of the passed [cmd2.plugin.CommandFinalizationData][] object contains a value. There are
 certain circumstances where these hooks may be called before the user input has been parsed, so you
 can't always rely on having a `cmd2.plugin.CommandFinalizationData.statement`.
 

docs/features/initialization.md

@@ -12,7 +12,7 @@ Here is a basic example `cmd2` application which demonstrates many capabilities
 
 ## Cmd class initializer
 
-A `cmd2.Cmd` instance or subclass instance is an interactive CLI application framework. There is no good reason to instantiate `Cmd` itself; rather, it's useful as a superclass of a class you define yourself in order to inherit `Cmd`'s methods and encapsulate action methods.
+A [cmd2.Cmd][] instance or subclass instance is an interactive CLI application framework. There is no good reason to instantiate `Cmd` itself; rather, it's useful as a superclass of a class you define yourself in order to inherit `Cmd`'s methods and encapsulate action methods.
 
 Certain things must be initialized within the `__init__()` method of your class derived from `cmd2.Cmd`(all arguments to `__init__()` are optional):
 

docs/features/misc.md

@@ -41,18 +41,19 @@ available when the application is in a specific state. When a command is disable
 up in the help menu or tab complete. If a user tries to run the command, a command-specific message
 supplied by the developer will be printed. The following functions support this feature.
 
-- **enable_command** : Enable an individual command
-- **enable_category** : Enable an entire category of commands
-- **disable_command** : Disable an individual command and set the message that will print when this
-  command is run or help is called on it while disabled
-- **disable_category** : Disable an entire category of commands and set the message that will print
-  when anything in this category is run or help is called on it while disabled
+- [enable_command][cmd2.Cmd.enable_command] : Enable an individual command
+- [enable_category][cmd2.Cmd.enable_category] : Enable an entire category of commands
+- [disable_command][cmd2.Cmd.disable_command] : Disable an individual command and set the message
+  that will print when this command is run or help is called on it while disabled
+- [disable_category][cmd2.Cmd.disable_category] : Disable an entire category of commands and set the
+  message that will print when anything in this category is run or help is called on it while
+  disabled
 
 See the definitions of these functions for descriptions of their arguments.
 
 See the `do_enable_commands()` and `do_disable_commands()` functions in the
-[HelpCategories](https://github.com/python-cmd2/cmd2/blob/main/examples/help_categories.py) example
-for a demonstration.
+[help_categories.py](https://github.com/python-cmd2/cmd2/blob/main/examples/help_categories.py)
+example for a demonstration.
 
 ## Default to shell
 
@@ -64,9 +65,9 @@ shortcut:
     (Cmd) !which python
     /usr/bin/python
 
-However, if the parameter `default_to_shell` is `True`, then _every_ command will be attempted on
-the operating system. Only if that attempt fails (i.e., produces a nonzero return value) will the
-application's own `default` method be called.
+However, if the parameter `default_to_shell` is `True`, then _every_ thing entered which doesn't
+match another command will be attempted on the operating system. Only if that attempt fails (i.e.,
+produces a nonzero return value) will the application's own `default` method be called.
 
     (Cmd) which python
     /usr/bin/python