Update docs

Author: ethanhann

docs-src/commands.md

@@ -8,27 +8,27 @@ They can be C# classes, lambda expressions, or CLI programs.
 The InEngine.Core package is required to create a C# class command. 
 Install it in a Visual Studio project.
 
-==Package Manager==
+**Package Manager**
 ```bash
 Install-Package InEngine.Core
 ```
 
-==Nuget CLI==
+**Nuget CLI**
 ```bash
 nuget install InEgine.Core
 ```
 
-==.NET CLI==
+**.NET CLI**
 ```bash
 dotnet add package InEngine.Core
 ```
 
-==Paket CLI==
+**Paket CLI**
 ```bash
 paket add InEngine.Core
 ```
 
-Adding a class that implements ==InEngine.Core.ICommand== is the simplest way to create a command.
+Adding a class that implements **InEngine.Core.ICommand** is the simplest way to create a command.
 
 ```c#
 using System;
@@ -47,7 +47,7 @@ namespace MyCommandPlugin
 ```
 
 A command that implements ICommand can be run directly or [queued](queuing), but it cannot be [scheduled](scheduling).
-Extending the ==InEngine.Core.AbstractCommand== class adds extra functionality, like a progress bar, and the ability to schedule the command using the scheduler.
+Extending the **InEngine.Core.AbstractCommand** class adds extra functionality, like a progress bar, and the ability to schedule the command using the scheduler.
 Minimally, the Run method should be overridden.
 
 ```c#
@@ -68,7 +68,7 @@ namespace MyCommandPlugin
 
 ## Run a Command
 
-Create a class that implements ==InEngine.Core.IOptions== in the same assembly as the command class.
+Create a class that implements **InEngine.Core.IOptions** in the same assembly as the command class.
 Add a VerbOptions attribute, from the CommandLine namespace, that defines the name of the command. 
 Optional help text can also be specified in the VerbOption attribute.
 The help text can be auto-generated from the attribute or manually specified in the GetUsage method if desired.
@@ -108,7 +108,7 @@ inengine.exe -pMyCommandPlugin my-command
 ### Executing Arbitrary Processes
 
 It isn't necessary to create C# classes to utilize InEngine.NET.
-Arbitrary commands can be run, with an argument list by leveraging the InEngine.Core plugin's ==proc== command.
+Arbitrary commands can be run, with an argument list by leveraging the InEngine.Core plugin's **proc** command.
 The command lists directory contents using "ls" with the "-lhp" switches:
 
 ```bash
@@ -151,7 +151,7 @@ Run inengine.exe with only the plugin specified:
 inengine.exe -pInEngine.Core
 ```
 
-The ==InEngine.Core== library is itself a plugin that contains queue-related and other commands. 
+The **InEngine.Core** library is itself a plugin that contains queue-related and other commands. 
 As an example, this is the help output for the core plugin.
 
 ```text
@@ -186,7 +186,7 @@ Run the command with the -h or --help arguments.
 inengine.exe -pInEngine.Core queue:publish -h
 ```
 
-The ==InEngine.Core== plugin's command to clear the InEngine.NET queues produces this help message. 
+The **InEngine.Core** plugin's command to clear the InEngine.NET queues produces this help message. 
 
 ```text
 InEngine 3.x
@@ -210,7 +210,7 @@ Copyright © 2017 Ethan Hann
 
 ## Writing Output
 
-The ==InEngine.Core.AbstractCommand== class provides some helper functions to output text to the console, for example:
+The **InEngine.Core.AbstractCommand** class provides some helper functions to output text to the console, for example:
 
 ```c#
 public override void Run()
@@ -278,7 +278,7 @@ The [NLog configuration](https://github.com/NLog/NLog/wiki/Tutorial#configuratio
 
 ## Progress Bar
 
-The ==InEngine.Core.AbstractCommand== class provides a ProgressBar property to show command progress in a terminal.
+The **InEngine.Core.AbstractCommand** class provides a ProgressBar property to show command progress in a terminal.
 This is how it is used:
 
 ```c#

docs-src/configuration.md

@@ -1,7 +1,7 @@
 # Configuration 
 
 Configuration is accomplished by modifying the appsettings.json file that comes with the InEngine.NET binary distribution.
-The ==-c, --configuration== argument can also be used to specify an alternate configuration file.
+The **-c, --configuration** argument can also be used to specify an alternate configuration file.
 
 
 ```json

docs-src/index.md

@@ -7,12 +7,12 @@ It also has a built-in command for launching external non-.NET programs.
 
 Get started by pulling the binaries from the [latest release](https://github.com/InEngine-NET/InEngine.NET/releases) on GitHub.
 
-Then run a command the ==echo== command from the core plugin:
+Then run a command the **echo** command from the core plugin:
 
 ```bash
 inengine.exe -pInEngine.Core echo --text"Hello, world"
 ```
-Or if you're a Linux or Mac OS X fan (like me!), use the ==inengine== shell script ([Mono](http://www.mono-project.com/download/) is required):
+Or if you're a Linux or Mac OS X fan (like me!), use the **inengine** shell script ([Mono](http://www.mono-project.com/download/) is required):
 
 ```bash
 inengine -pInEngine.Core echo --text"Hello, world"
@@ -36,31 +36,31 @@ There are a lot of [queuing](queuing) features, but this is the gist...
 
 Want to queue our example echo command to run in the background or possibly on another server?
 
-Use the core plugin's ==queue:publish== command:
+Use the core plugin's **queue:publish** command:
 
 ```bash
 inengine.exe -pInEngine.Core queue:publish --command-plugin=InEngine.Core.dll --command-verb=echo --args "text=Hello, world"
 ``` 
 
 How do we consume that queued echo command?
 
-Use the core plugin's ==queue:consume== command of course:
+Use the core plugin's **queue:consume** command of course:
 
 ```bash
 inengine.exe -pInEngine.Core queue:consume
 ``` 
 
 ## How do I run non-.NET commands?
 
-There is a special ==proc== command in the core plugin that allows for the execution of any program you can run at the command line. 
+There is a special **proc** command in the core plugin that allows for the execution of any program you can run at the command line. 
 
-For example, create a python script called ==helloworld.py== that contains this:
+For example, create a python script called **helloworld.py** that contains this:
 
 ```python
 print 'Hello, world!'
 ```
 
-Now execute it with the ==proc== command:
+Now execute it with the **proc** command:
 
 ```bash
 inengine -pInEngine.Core proc --command=/usr/bin/python --args=helloworld.py

docs-src/queuing.md

@@ -43,7 +43,7 @@ This driver can be useful for plugin development and testing.
 
 ### With C# Classes
 
-[Commands](commands) can be published programmatically with the ==InEngine.Core.Queuing.Queue== class:
+[Commands](commands) can be published programmatically with the **InEngine.Core.Queuing.Queue** class:
 
 ```c#
 Queue.Make().Publish(new MyCommand());
@@ -63,7 +63,7 @@ Queue.Make(true).Publish(new MyCommand());
 ### With Lambda Expressions
 
 Lambda expressions, aka anonymous functions, can be queued.
-The disadvantage to queuing lambdas is that the helpful functionality available in ==InEngine.Core.AbstractCommand== is not available.  
+The disadvantage to queuing lambdas is that the helpful functionality available in **InEngine.Core.AbstractCommand** is not available.  
 
 This is how you queue a lambda:
 
@@ -108,7 +108,7 @@ Subject.Publish(new List<AbstractCommand>() {
 ### From the Command Line
 
 Commands can be published from the command line as well.
-Note that all queue commands reside in the ==InEngine.Core== plugin.
+Note that all queue commands reside in the **InEngine.Core** plugin.
 This is an example of how to publish a command from the CLI by specifying the command's plugin, class name, and arguments:
 
 ```bash
@@ -151,7 +151,7 @@ Commands can be consumed from the command line as well with this simple command:
 inengine.exe -pInEngine.Core queue:consume
 ```
 
-Use the ==--secondary== argument to consume the secondary queue instead of the primary queue:
+Use the **--secondary** argument to consume the secondary queue instead of the primary queue:
 
 ```bash
 inengine.exe -pInEngine.Core queue:consume --secondary
@@ -166,15 +166,15 @@ There are a variety of [ways to run the scheduler](scheduling/#running-the-sched
 
 ### Viewing Queue Lengths
 
-The ==queue:length== command shows a quick summary of pending, in-progress, and failed commands in the primary and secondary queues:
+The **queue:length** command shows a quick summary of pending, in-progress, and failed commands in the primary and secondary queues:
 
 ```bash
 inengine.exe -pInEngine.Core queue:length
 ```
 
 ### Peek at Queued Commands
 
-The ==queue:peek== command allows for queued commands to be inspected:
+The **queue:peek** command allows for queued commands to be inspected:
 
 ```bash
 inengine.exe -pInEngine.Core queue:peek --pending --in-progress --failed
@@ -208,7 +208,7 @@ inengine.exe -pInEngine.Core queue:peek --pending --from=100 --to=200
 ## Handling Failed Commands
 
 Commands that throw an exception are put in a special "failed" queue. 
-They can be republished with the ==queue:republish== command:
+They can be republished with the **queue:republish** command:
 
 ```bash
 inengine.exe -pInEngine.Core queue:republish