craig.oates
/
console.waterworks
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix broken links (again).

master
Craig Oates 4 years ago
parent
29aec587f9
commit
3c9d9dda91
18 changed files with 93 additions and 93 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      CW-Console-Flow.md
  2. 10
      CW-Console-Home.md
  3. 18
      CW-Console-Project-Breakdown.md
  4. 6
      CW-Tests-Home.md
  5. 14
      CW-Tests-Project-Breakdown.md
  6. 16
      Console.Waterworks-Flow.md
  7. 4
      Console.Waterworks-Home.md
  8. 16
      Console.Waterworks-Project-Breakdown.md
  9. 18
      Home.md
  10. 4
      Repository-Breakdown.md
  11. 16
      Source-Code-Home.md
  12. 2
      The-Help-Attributes.md
  13. 6
      Unit-Tests-Overview.md
  14. 8
      Using-CW-Console.md
  15. 8
      Using-the-Help-Attributes.md
  16. 10
      Wiring-Console.Waterworks-into-Your-Project.md
  17. 2
      Writing-Command-Methods.md
  18. 16
      _Sidebar.md

12
CW-Console-Flow.md
Unescape

@ -1,6 +1,6 @@
To help you get up to speed with how CW_Console works, please conside the image below.
To help you get up to speed with how CW-Console works, please conside the image below.
![cw_console data flow](cw_console-data-flow.png)
![cw-console data flow](cw-console-data-flow.png)
The way it works is as follows:
@ -10,8 +10,8 @@ The way it works is as follows:
That's the "happy path" version at least. If the end-user enters an invalid command, C.W. will return an error message.
![cw_console bad input data flow](cw_console-data-flow-bad-input.png)
![cw_console bad input run-time example](invalid-command-input.gif)
![cw-console bad input data flow](cw-console-data-flow-bad-input.png)
![cw-console bad input run-time example](invalid-command-input.gif)
For C.W. to operate as designed, it needs to rely on certain things, which are;
@ -21,5 +21,5 @@ For C.W. to operate as designed, it needs to rely on certain things, which are;
If you are new to the project, I recommend you take a moment to look at the code in "Program.cs" and "ConsoleCommand.cs". Once you have a good grasp of what it happening in "Program.cs", you should not need to look at it again. That is when you can start to focus on the code in "ConsoleCommands.cs" -- the place where most of the work is. The links for these files are as follows:
* [Program.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/Program.cs)
* [ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/ConsoleCommands.cs)
* [Program.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/Program.cs)
* [ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/ConsoleCommands.cs)

10
CW-Console-Home.md
Unescape

@ -1,10 +1,10 @@
This section focuses on the source code within the project called "CW_Console". This is the console project which provides users with a way to uses the features in "Console.Waterworks" without the need to write code. If you would like to know more about the other projects, please use the following links:
This section focuses on the source code within the project called "CW-Console". This is the console project which provides users with a way to uses the features in "Console.Waterworks" without the need to write code. If you would like to know more about the other projects, please use the following links:
- [Console.Waterworks](Console.Waterworks-Home)
- [CW_Tests](CW_Tests-Home)
- [CW-Tests](CW-Tests-Home)
## Table of Contents
- [CW_Console Project Breakdown](CW_Console-Project-Breakdown)
- [CW_Console Flow](CW_Console-Flow)
- [Using CW_Console](Using-CW_Console)
- [CW-Console Project Breakdown](CW-Console-Project-Breakdown)
- [CW-Console Flow](CW-Console-Flow)
- [Using CW-Console](Using-CW-Console)

18
CW-Console-Project-Breakdown.md
Unescape

@ -1,26 +1,26 @@
![cw_console selected project](cw_console-selected.png)
![cw-console selected project](cw-console-selected.png)
This project is a traditional .Net 4.7 console program, written in C#. Within it, you will find one folder and six files. Having said that, you will spend most of your time in one file, called "ConsoleCommands.cs". This is after you have grasped what is happening in  "Program.cs", though.
The following files are standard C# files in a Visual Studio (console) project:
* [App.config](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/App.config)
* [CW_Console.csproj](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/CW_Console.csproj) (the ".csproj" bit is the standard part)
* [packages.config](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/packages.config)
* [AssemblyInfo.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/Properties/AssemblyInfo.cs) (residing in the "Properties" folder)
* [App.config](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/App.config)
* [CW-Console.csproj](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/CW-Console.csproj) (the ".csproj" bit is the standard part)
* [packages.config](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/packages.config)
* [AssemblyInfo.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/Properties/AssemblyInfo.cs) (residing in the "Properties" folder)
With these files being standard files, in a typical C# project, I will not spend any time of them. What I will do instead is focus on the project specific files. If you are more interested with jumping straight into the code, start at "Program.cs". then move onto "ConsoleCommands.cs".
The links for these files are as follows:
* [Program.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/Program.cs)
* [ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/ConsoleCommands.cs)
* [Program.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/Program.cs)
* [ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/ConsoleCommands.cs)
![cw_console file structure](cw_console-file-structure.png)
![cw-console file structure](cw-console-file-structure.png)
"Program.cs" is the entry point into the system -- it is where `Main` resides. The purpose of `Main` in this context is to set-up in "input-loop", using Console.Waterworks. Once you have grasped what/how it is doing that, you should never need to go back in this folder.
"ConsoleCommands.cs" houses the all the command-methods. The methods you write in here are what the end-user will need to type into the console to execute said methods. It is important to note the end-user must match the command-method name exactly. For example, if you name one of your command-methods `Request_Data`, the end-user must enter "Request_Data" into the console -- "requestdata" and "request-data" will not work.
"ConsoleCommands.cs" houses the all the command-methods. The methods you write in here are what the end-user will need to type into the console to execute said methods. It is important to note the end-user must match the command-method name exactly. For example, if you name one of your command-methods `Request-Data`, the end-user must enter "Request-Data" into the console -- "requestdata" and "request-data" will not work.
As an aside, "Command-method" is a term specific to this project. They are regular methods which live in "ConsoleCommands.cs". I call them that to help differentiate them from other methods throughout the system. Feel free to ignore this term or call them whatever makes sense to you.

6
CW-Tests-Home.md
Unescape

@ -1,9 +1,9 @@
This section focuses on the source code within the "CW_Tests" project. As the name implies, this project houses the unit and property tests for the the other two projects. If you would like to know more about the other projects, please the following links:
This section focuses on the source code within the "CW-Tests" project. As the name implies, this project houses the unit and property tests for the the other two projects. If you would like to know more about the other projects, please the following links:
- [CW_Console](CW_Console-Home) (The console project)
- [CW-Console](CW-Console-Home) (The console project)
- [Console.Waterworks](Console.Waterworks-Home)
## Table of Contents
- [CW_Tests Project Breakdown](CW_Tests-Project-Breakdown)
- [CW-Tests Project Breakdown](CW-Tests-Project-Breakdown)
- [Unit Tests Overview](Unit-Tests-Overview)

14
CW-Tests-Project-Breakdown.md
Unescape

@ -1,12 +1,12 @@
![cw_tests project selected](cw_tests-selected.png)
![cw-tests project selected](cw-tests-selected.png)
This is a traditional .Net 4.7 library, written in C#. Its main purpose is to house the solution's unit tests.
Within the project, you will see four files and a folder. Of the four files, you will spend most of your time in one which is called "CW_ConsoleTest.cs"; This is where the tests are. The remaining files are standard Visual Studio (C#) project files. Links to the above files are as follows:
Within the project, you will see four files and a folder. Of the four files, you will spend most of your time in one which is called "CW-ConsoleTest.cs"; This is where the tests are. The remaining files are standard Visual Studio (C#) project files. Links to the above files are as follows:
* [AssemblyInfo.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Tests/Properties/AssemblyInfo.cs) (in the "Properties" folder)
* [CW_ConsoleTest.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Tests/CW_ConsoleTest.cs)
* [CW_Tests.csproj](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Tests/CW_Tests.csproj)
* [packages.config](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Tests/packages.config)
* [AssemblyInfo.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Tests/Properties/AssemblyInfo.cs) (in the "Properties" folder)
* [CW-ConsoleTest.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Tests/CW-ConsoleTest.cs)
* [CW-Tests.csproj](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Tests/CW-Tests.csproj)
* [packages.config](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Tests/packages.config)
![cw_tests file structure](cw_tests-file-structure.png)
![cw-tests file structure](cw-tests-file-structure.png)

16
Console.Waterworks-Flow.md
Unescape

@ -4,26 +4,26 @@ To help you get up to speed on the way Console.Waterworks (C.W.) works, please v
The way it works is as follows:
1. You call a method in `CW_Liaison`;
1. You call a method in `CW-Liaison`;
2. which then forwards it on to `CoOridinator`;
3. `CoOrdinator` then **usually** calls the various methods within the "specialist" classes (`CommandsSpecialist`, `CoersionSpecialist` Etc.);
4. When the task is complete, `CoOrdinator` returns the result to `CW_Liaison`; and then
5. `CW_Liaison` returns the result to the method which made the original call in C.W.
4. When the task is complete, `CoOrdinator` returns the result to `CW-Liaison`; and then
5. `CW-Liaison` returns the result to the method which made the original call in C.W.
If you are unsure what the methods in `CW_Liaison` do, use Visual Studio's intellisense. You can, also, read the code in `CW_Liaison` with the following link:
If you are unsure what the methods in `CW-Liaison` do, use Visual Studio's intellisense. You can, also, read the code in `CW-Liaison` with the following link:
* [CW_Liaison.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/CW_Liaison.cs)
* [CW-Liaison.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/CW-Liaison.cs)
Below is a more detailed version of the image above.
![console.waterworks detailed data flow](console.waterworks-internal-data-flow.png)
One of the main stays of C.W. is how it controls the flow of data. It tries to maintain a high degree of consistency and reduce "cross-pollination". What I mean by that is C.W.  tries to manage how, when and where the data flows via its `CoOrdinator` class. Each "specialist" class only deals with the `CoOrdinator`. They (specialists) do not call methods to/from each other. If one specialist needs information from another, it must go through the `CoOrdinator`. If you are someone new to the project, I am hopeful this consistency will help you learn the system quicker. With that said, there are a several places where this pattern is not applied. They are when you are dealing with `CW_Logger`, `CW_Constants` and the "attribute" classes. These classes are accessible throughout the whole system. So, you can call them whenever/wherever you want. They are not accessible outside the project, though. In other words, you can only do this when working within this project's source code and not when you are **consuming** C.W. as a NuGet package.
One of the main stays of C.W. is how it controls the flow of data. It tries to maintain a high degree of consistency and reduce "cross-pollination". What I mean by that is C.W.  tries to manage how, when and where the data flows via its `CoOrdinator` class. Each "specialist" class only deals with the `CoOrdinator`. They (specialists) do not call methods to/from each other. If one specialist needs information from another, it must go through the `CoOrdinator`. If you are someone new to the project, I am hopeful this consistency will help you learn the system quicker. With that said, there are a several places where this pattern is not applied. They are when you are dealing with `CW-Logger`, `CW-Constants` and the "attribute" classes. These classes are accessible throughout the whole system. So, you can call them whenever/wherever you want. They are not accessible outside the project, though. In other words, you can only do this when working within this project's source code and not when you are **consuming** C.W. as a NuGet package.
Here is a list of links for the various files/classes mentioned above:
* [CoOrdinator.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/CoOrdinators/CoOrdinator.cs)
* [The "Specialists" folder](https://git.abbether.net/craig.oates/Console.Waterworks/tree/master/Console.Waterworks/Console.Waterworks/Specialists)
* [CW_Logger.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Loggers/CW_Logger.cs)
* [CW_Constants.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Constants/CW_Constants.cs)
* [CW-Logger.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Loggers/CW-Logger.cs)
* [CW-Constants.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Constants/CW-Constants.cs)
* [The "Attributes" folder](https://git.abbether.net/craig.oates/Console.Waterworks/tree/master/Console.Waterworks/Console.Waterworks/Attributes)

4
Console.Waterworks-Home.md
Unescape

@ -1,7 +1,7 @@
This section focuses on the source code within the project called "Console.Waterworks". This is a .Net 4.7 library which provides users with a way to create command-based console programs. If you would like to know more about the other projects, please use the following links:
- [CW_Console](CW_Console-Home) (The console project)
- [CW_Tests](CW_Tests-Home) (The testing library)
- [CW-Console](CW-Console-Home) (The console project)
- [CW-Tests](CW-Tests-Home) (The testing library)
## Table of Contents

16
Console.Waterworks-Project-Breakdown.md
Unescape

@ -4,7 +4,7 @@ This project is a .Net 4.7 library, written in C#. Within the project, you will
![console.waterworks project overview](console.waterworks-project-breakdown.png)
Before going into further detail...  If you want to jump straight into the code, [CW_Liaison.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/CW_Liaison.cs) is the place to start. It is the entry point to the library when using it in a project.
Before going into further detail...  If you want to jump straight into the code, [CW-Liaison.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/CW-Liaison.cs) is the place to start. It is the entry point to the library when using it in a project.
"Console.Waterworks.csproj" is a typical  C# project file -- found with all Visual Studio projects. So, you should not need to touch it and the reason why I will not focus on it. The same applies to "Assemblyinfo.cs" which resides in "Properties".
@ -28,7 +28,7 @@ This folder houses the following files:
* [ParametersAttribute.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Attributes/ParametersAttribute.cs)
* [UsageAttibute.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Attributes/UsageAttribute.cs)
These attributes (files) are what you decorate your command-methods with. If a user decides to use Console.Waterworks' (C.W.) built-in run-time _help system_, these files are what they will end up using. The classes/objects within these files tend to only interact with the `HelpSpecialist`.
These attributes (files) are what you decorate your command-methods with. If a user decides to use Console.Waterworks' (C.W.) built-in run-time -help system-, these files are what they will end up using. The classes/objects within these files tend to only interact with the `HelpSpecialist`.
To help you get a sense of how to use these files/classes, please use the following links (all found in "As a NuGet" section of this wiki):
@ -42,7 +42,7 @@ The only files in this folder is:
* [CoOrdinator.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/CoOrdinators/CoOrdinator.cs)
_With that said, there is nothing stopping you from adding more Co-Ordinator classes in the future. It all depends on how complex the library gets._
-With that said, there is nothing stopping you from adding more Co-Ordinator classes in the future. It all depends on how complex the library gets.-
This file connects all the other files together. **This is most critical part of the system**. When you have grasped what is happening in `CoOrdinator`, everything else should start falling into place. `CoOrdinator` connects all the other files together by assigning them tasks. When they have finished their tasks, they return their results to the `CoOrdinator`. From there, `CoOrdinator` will forward the result on to the appropriate class/object. The main idea behind `CoOrdinator` is to limit/control the flow of data in the system. To help explain the above, please read the following page:
@ -52,19 +52,19 @@ This file connects all the other files together. **This is most critical part of
There is only one file in "Constants" which is:
* [CW_Constants.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Constants/CW_Constants.cs)
* [CW-Constants.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Constants/CW-Constants.cs)
This files handles the libraries' constant variables. You have access to `CW_Constants` throughout the codebase but consumers of C.W. do not. Another way look at this file is as the libraries' settings/preferences (as code of course).
This files handles the libraries' constant variables. You have access to `CW-Constants` throughout the codebase but consumers of C.W. do not. Another way look at this file is as the libraries' settings/preferences (as code of course).
## Loggers
The only file in here is:
* [CW_Logger.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Loggers/CW_Logger.cs)
* [CW-Logger.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/Console.Waterworks/Loggers/CW-Logger.cs)
Its main purpose is to document the flow of C.W. I tend to use it for testing purposes most of the time. An important note to make is none of the logging events will show in projects which _consume_ this library (as a NuGet package). Also, I tend to control the  `CW_Logger`  via `CoOrdinator`, for the most part. You are not limited to using `CW_Logger` that way, though. If you want, you can call/control is at any point throughout the system.
Its main purpose is to document the flow of C.W. I tend to use it for testing purposes most of the time. An important note to make is none of the logging events will show in projects which -consume- this library (as a NuGet package). Also, I tend to control the  `CW-Logger`  via `CoOrdinator`, for the most part. You are not limited to using `CW-Logger` that way, though. If you want, you can call/control is at any point throughout the system.
_The point about adding more `Co-Ordinator` classes (Loggers in this case) to the system in the future applies here._
-The point about adding more `Co-Ordinator` classes (Loggers in this case) to the system in the future applies here.-
## Models

18
Home.md
Unescape

@ -20,7 +20,7 @@ Before continuing, I recommend you are familiar with the following:
1. I will usually refer to Console.Waterworks as "C.W.".
2. I will use "console program" and "console project" interchangeably. This is because of how Visual Studio's "file system" works. Overall, there is a "solution" which holds "projects". A project can consist of things like a console program. In-effect, this makes it a "program" and a "project". Hopefully, this makes sense when viewed in context.
3. The repository has a testing library called "CW_Tests". I will quite often refer to it as "test/testing library" in the wiki.
3. The repository has a testing library called "CW-Tests". I will quite often refer to it as "test/testing library" in the wiki.
4. In an attempt to keep a level of consistency, I will abbreviate words with a full-stop. So, "HTML" will be written as "H.T.M.L.". This is because I usually abbreviate "non-tech." words this way and I am not keen on using the different styles in the same text.
### 2. About Console.Waterworks.Core
@ -51,17 +51,17 @@ Because it is port of this project, its wiki focuses on how to **use** it as a N
- [Coercion Types List](Coercion-Types-List)
- [The Help Attributes](The-Help-Attributes)
#### CW_Console
#### CW-Console
- [CW_Console Home](CW_Console-Home)
- [CW_Console Project Breakdown](CW_Console-Project-Breakdown)
- [CW_Console Flow](CW_Console-Flow)
- [Using CW_Console](Using-CW_Console)
- [CW-Console Home](CW-Console-Home)
- [CW-Console Project Breakdown](CW-Console-Project-Breakdown)
- [CW-Console Flow](CW-Console-Flow)
- [Using CW-Console](Using-CW-Console)
#### CW_Tests
#### CW-Tests
- [CW_Tests Home](CW_Tests-Home)
- [CW_Tests Project Breakdown](CW_Tests-Project-Breakdown)
- [CW-Tests Home](CW-Tests-Home)
- [CW-Tests Project Breakdown](CW-Tests-Project-Breakdown)
- [Unit Tests Overview](Unit-Tests-Overview)
### As a NuGet

4
Repository-Breakdown.md
Unescape

@ -6,10 +6,10 @@ The code-base in this repository is a typical Visual Studio solution. Within the
All three projects are written in C#.
The solution's main project is the .Net 4.7 library, called Console.Waterworks. This is where you will most likely want to start your exploration of the code-base. The other two are secondary but important parts of the solution. Their names are CW_Console and CW_Tests. To help you grasp what that looks like, please consider the following image.
The solution's main project is the .Net 4.7 library, called Console.Waterworks. This is where you will most likely want to start your exploration of the code-base. The other two are secondary but important parts of the solution. Their names are CW-Console and CW-Tests. To help you grasp what that looks like, please consider the following image.
![solution overview](solution-overview.png)
The image below shows how each project is referenced within the solution. Console.Waterworks and CW_Console are referenced in CW_Tests; And, Console.Waterworks is referenced in CW_Console. This leaves Console.Waterworks referencing none of the other two.
The image below shows how each project is referenced within the solution. Console.Waterworks and CW-Console are referenced in CW-Tests; And, Console.Waterworks is referenced in CW-Console. This leaves Console.Waterworks referencing none of the other two.
![project references](project-references.png)

16
Source-Code-Home.md
Unescape

@ -14,15 +14,15 @@ This section is for those wanting to work with the repositories source code. If
- [Coercion Types List](Coercion-Types-List)
- [The Help Attributes](The-Help-Attributes)
### CW_Console
### CW-Console
- [CW_Console Home](CW_Console-Home)
- [CW_Console Project Breakdown](CW_Console-Project-Breakdown)
- [CW_Console Flow](CW_Console-Flow)
- [Using CW_Console](Using-CW_Console)
- [CW-Console Home](CW-Console-Home)
- [CW-Console Project Breakdown](CW-Console-Project-Breakdown)
- [CW-Console Flow](CW-Console-Flow)
- [Using CW-Console](Using-CW-Console)
### CW_Tests
### CW-Tests
- [CW_Tests Home](CW_Tests-Home)
- [CW_Tests Project Breakdown](CW_Tests-Project-Breakdown)
- [CW-Tests Home](CW-Tests-Home)
- [CW-Tests Project Breakdown](CW-Tests-Project-Breakdown)
- [Unit Tests Overview](Unit-Tests-Overview)

2
The-Help-Attributes.md
Unescape

@ -7,7 +7,7 @@ To use the "Help Section" feature, you will need to know about the four attribut
To you get a sense of how they look in practice, please use the links below:
- [ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/ConsoleCommands.cs) (part of CW_Console)
- [ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/ConsoleCommands.cs) (part of CW-Console)
- [Wet Pancakes' ConsoleCommands.cs](https://git.abbether.net/craig.oates/Wet-Pancake/blob/master/WetPancakeCLI/ConsoleCommands.cs) (this uses Console.Waterworks in a slightly more advance manner)
- [Smouldering Beach Ball's ConsoleCommands.fs](https://git.abbether.net/craig.oates/Smouldering-Beach-Ball/blob/master/SmoulderingBeachBallCLI/ConsoleCommands.fs) (this uses the attributes with F#)

6
Unit-Tests-Overview.md
Unescape

@ -1,13 +1,13 @@
Within "CW_Tests", you will find a collection of unit tests -- which I wrote with xUnit. If you are unfamiliar with xUnit and unit tests in-general, please use the following links:
Within "CW-Tests", you will find a collection of unit tests -- which I wrote with xUnit. If you are unfamiliar with xUnit and unit tests in-general, please use the following links:
* [xUnit](https://xunit.net/)
* [Unit Testing Overview](https://docs.microsoft.com/en-us/dotnet/core/testing/)
It is worth pointing out CW_Tests uses xUnit's Test Runner for Visual Stuio which means you can use Visual Studio's Test Explorer. This allows you to see the project's (unit) tests with a graphical user interface. If you are unsure what that is, below is a screenshot of it looks like.
It is worth pointing out CW-Tests uses xUnit's Test Runner for Visual Stuio which means you can use Visual Studio's Test Explorer. This allows you to see the project's (unit) tests with a graphical user interface. If you are unsure what that is, below is a screenshot of it looks like.
![visual studio test explorer](visual-studio-test-explorer.png)
As you can see, it is a good way to determine what tests are passing and failing. On top of that, it highlights how I have organised the tests (in CW_Tests).
As you can see, it is a good way to determine what tests are passing and failing. On top of that, it highlights how I have organised the tests (in CW-Tests).
For more information about Visual Studio's Test Explorer, please the following link:

8
Using-CW-Console.md
Unescape

@ -1,10 +1,10 @@
This repository provides a traditional .Net 4.7 console program. Its main purpose is to provide a way to test the Console.Waterworks (C.W.) library at run-time. I should point out, this console does not come with a separate installer. So, you will need to build the project after cloning the repository.
To operate CW_Console, you enter commands and its required arguments into the console -- like other Command Line Interfaces (C.L.I.). With that said, this console program operates in a different manner to PowerShell, for example. This means you need to put aside your assumptions if you are a regular user of shells/terminals/consoles.
To operate CW-Console, you enter commands and its required arguments into the console -- like other Command Line Interfaces (C.L.I.). With that said, this console program operates in a different manner to PowerShell, for example. This means you need to put aside your assumptions if you are a regular user of shells/terminals/consoles.
When you start the console, you will see something similar to the image below.
![cw_console start screen](cw_console-run-time-start.png)
![cw-console start screen](cw-console-run-time-start.png)
From here, you can begin entering commands. Before continuing, it is worth noting the "Help" command. When you enter `Help` into the console prompt, the console will show you a list of all the commands the program can run.
@ -12,7 +12,7 @@ From here, you can begin entering commands. Before continuing, it is worth notin
If you would like to view the source code of the commands, you can peruse through them all using the following link:
* [ConsoleCommands.fs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/ConsoleCommands.cs)
* [ConsoleCommands.fs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/ConsoleCommands.cs)
If you go through the "Help" section, you will notice most of the commands have input arguments. From your point-of-view, they are typical (input) types (`int`, `string` Etc.). There are limitations to these arguments but you can extend them if you want; I do not recommend you do that, though. If you would like to know more about about these limitations, please use the following link:
@ -22,7 +22,7 @@ You should not notice the limitations for the most part. Although, if you are wa
## Console A.P.I.
One of the main purposes of CW_Console is to provide a way to test C.W. at run-time. Because of this, the console does not provide interesting features -- outside its testing purposes. So, there is no "real" application program interface (A.P.I.) to document. With that said, here is a list of the console's commands, for the sake of completeness.
One of the main purposes of CW-Console is to provide a way to test C.W. at run-time. Because of this, the console does not provide interesting features -- outside its testing purposes. So, there is no "real" application program interface (A.P.I.) to document. With that said, here is a list of the console's commands, for the sake of completeness.
### `Help`

8
Using-the-Help-Attributes.md
Unescape

@ -1,4 +1,4 @@
To help users discover features within your console program, Console.Waterworks (C.W.) provides a run-time "help" section. It does this by using the (C#/.Net) attributes you attach to your command-methods. It is, also, optional. So, you do not need to decorate your command-methods if you do not want to. If you have cloned this repository, you can see this in action. To do so, run CW_Console (press F5) and enter "Help" into the prompt. You should see a list of available commands, a description of what they do and how to use them.
To help users discover features within your console program, Console.Waterworks (C.W.) provides a run-time "help" section. It does this by using the (C#/.Net) attributes you attach to your command-methods. It is, also, optional. So, you do not need to decorate your command-methods if you do not want to. If you have cloned this repository, you can see this in action. To do so, run CW-Console (press F5) and enter "Help" into the prompt. You should see a list of available commands, a description of what they do and how to use them.
![screenshot of help at run-time](run-time-help.gif)
@ -20,7 +20,7 @@ Within the "help" command-method, enter the following code:
```c#
public static string help()
{
CW_Liaison liaison = new CW_Liaison();
CW-Liaison liaison = new CW-Liaison();
// Don't forget your name-space for your ConsoleCommands class
return liaison.RequestHelpDocumentation("YOUR NAME-SPACE HERE");
}
@ -48,6 +48,6 @@ public static string Test()
A nice side-effect of the attributes is your command-methods are "self-documented". And, because this bit of code is used by the end-user, there is an extra incentive to keep the documentation up-to-date. Who said I'm not an optimist...
For the sake of completeness, I have provided a link to the `ConsoleCommands` class in CW_Console. Hopefully, seeing more realistic examples will help reduce any confusion. The link is as follows:
For the sake of completeness, I have provided a link to the `ConsoleCommands` class in CW-Console. Hopefully, seeing more realistic examples will help reduce any confusion. The link is as follows:
- [ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/ConsoleCommands.cs)
- [ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/ConsoleCommands.cs)

10
Wiring-Console.Waterworks-into-Your-Project.md
Unescape

@ -6,7 +6,7 @@ Once you have added C.W. to your console project, you can begin using it. One th
```c#
// Do not forget change the ConsoleCommands name-space in Run.
var liaison = new CW_Liaison();
var liaison = new CW-Liaison();
liaison.Run("YOUR CONSOLECOMMADS.CS NAME-SPACE GOES HERE.", true);
```
@ -23,14 +23,14 @@ Overall, your Program.cs should look similar to the code below,
using Console.Waterworks;
using System;
namespace CW_Console // This will differ in your project.
namespace CW-Console // This will differ in your project.
{
class Program
{
static void Main(string[] args)
{
var liaison = new CW_Liaison();
liaison.Run("CW_Console", true);
var liaison = new CW-Liaison();
liaison.Run("CW-Console", true);
}
}
}
@ -55,7 +55,7 @@ When you have done that, your ConsoleCommands.cs file should look similar to the
using System;
using Console.Waterworks;
namespace CW_Console // This will be different to yours.
namespace CW-Console // This will be different to yours.
{
public static class ConsoleCommands
{

2
Writing-Command-Methods.md
Unescape

@ -23,7 +23,7 @@ public static string CommandMethodName()
More examples can be found at the following links:
- [CW_Console's ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW_Console/ConsoleCommands.cs)
- [CW-Console's ConsoleCommands.cs](https://git.abbether.net/craig.oates/Console.Waterworks/blob/master/Console.Waterworks/CW-Console/ConsoleCommands.cs)
What is important to note here is the importance of the command-method names. The names you use are the exact same commands your end-user will enter at run-time. The console's input is, also, case-sensitive. This means you can have two command-methods called `Test` and `test` and have them do different things.

16
_Sidebar.md
Unescape

@ -19,17 +19,17 @@
- [Coercion Types List](Coercion-Types-List)
- [The Help Attributes](The-Help-Attributes)
#### CW_Console
#### CW-Console
- [CW_Console Home](CW_Console-Home)
- [CW_Console Project Breakdown](CW_Console-Project-Breakdown)
- [CW_Console Flow](CW_Console-Flow)
- [Using CW_Console](Using-CW_Console)
- [CW-Console Home](CW-Console-Home)
- [CW-Console Project Breakdown](CW-Console-Project-Breakdown)
- [CW-Console Flow](CW-Console-Flow)
- [Using CW-Console](Using-CW-Console)
#### CW_Tests
#### CW-Tests
- [CW_Tests Home](CW_Tests-Home)
- [CW_Tests Project Breakdown](CW_Tests-Project-Breakdown)
- [CW-Tests Home](CW-Tests-Home)
- [CW-Tests Project Breakdown](CW-Tests-Project-Breakdown)
- [Unit Tests Overview](Unit-Tests-Overview)
### As a NuGet

Write Preview
Loading…
Cancel
Save