Version 1.0.4.0

Author: PowerCommands

Docs/ChainCommands.md

@@ -0,0 +1,50 @@
+# Read, Write and navigate to files and directories
+
+From version 1.0.4.0 of PowerCommands you can call two commands using one line, using the | character, at the moment it is limited to two commands but the plan is to allow as many commands as you like in a call chain.
+
+The code below shows an example on how it could be used, in this case I first run the command `output` which is a really simple command that prints out what you input in the flag `--text`, then we use the | to let the runtime know that one more command should be run, in this case it is the file command, I am adding a --target flag with a file name.
+
+![Alt text](images/pipe_call.png?raw=true "Chain of commands")
+
+## Handling the output from the previous command
+The target command must implement code to work as a target command, let´s take a look on how this is implemented in the FileCommand class.
+
+![Alt text](images/file_command.png?raw=true "Handling the output from the previous command")
+
+The first row shows how a command can grab the result from the previous command.
+
+```var latestCommandResult = IPowerCommandsRuntime.DefaultInstance?.Latest;```
+
+If you want create a command that explore this, it could look like this.
+
+```
+[PowerCommandDesign(description: "Run commands that supports pipe functionality.",
+                        example: "//First run this command and then the version command|version [PIPE] pipe")]
+public class PipeCommand(string identifier, PowerCommandsConfiguration configuration) : CdCommand(identifier, configuration)
+{
+    public override RunResult Run()
+    {
+        Console.Clear();
+        var result = IPowerCommandsRuntime.DefaultInstance?.Latest;
+        if (result == null) return Ok();
+        WriteLine($"Previous command: {result!.ExecutingCommand.Identifier}");
+        WriteLine($"Previous output length: {result!.Output.Length}");
+        WriteLine($"Previous command status: {result!.Status}");
+        WriteLine($"Previous command input: {result!.Input.Raw}");
+        var retVal = Ok();
+        return retVal;
+    }
+}
+```
+
+Read more about:
+
+[Read and write files with FileCommand](ReadWriteFileHandler.md)
+
+[Design your Command](Design_command.md)
+
+[Input](Input.md)
+
+[PowerCommands Design Attribute](PowerCommandDesignAttribute.md)
+
+[Back to start](https://github.com/PowerCommands/PowerCommands2022/blob/main/Docs/README.md)

Docs/CommandBase.md

@@ -1,6 +1,6 @@
 # CommandBase
 
-CommandBase is the base class for most of your Command classes, it has some pracical help classes that you could use in your Command classes.
+CommandBase is the base class for most of your Command classes, it has some practical help classes that you could use in your Command classes.
 
 But before that lets have a look on the contract that all Commands must implement to work properly and... of course to even compile.
 
@@ -19,11 +19,11 @@ The Identifier and the InitializeRun will be used by the Core Framework, your wi
 ## Class diagram
 ![Alt text](images/CommandBase.png?raw=true "Command Base")
 
-As you could see there are helper methods and the important properties Configuration and Input. Input is cruisal for the Run methods without access to the Input, your code is "blind" and could only do static things that ignores the console input. The helper methods is for creating the return result for the Run methods and other helper is for [output](ConsoleOutput.md) to the console.
+As you could see there are helper methods and the important properties Configuration and Input. Input is crucial for the Run methods without access to the Input, your code is "blind" and could only do static things that ignores the console input. The helper methods is for creating the return result for the Run methods and other helper is for [output](ConsoleOutput.md) to the console.
 
 ## Create your own BaseCommand
 
-There are many use cases where it makes sense to create a base class for your other commands in your CLI applikation, lets say that you always need access to a keyvault and you do not want to repeat that code in every command you do. Here are som guidelines to help you.
+There are many use cases where it makes sense to create a base class for your other commands in your CLI application, lets say that you always need access to a keyvault and you do not want to repeat that code in every command you do. Here are som guidelines to help you.
  - The name should not end with Command, some examples on good naming could be VaultCommandBase or EntityFrameworkCommandBase
  - If the class only is used to be inherited by other commands, it is good ide to declare it as an abstract class.
  - Let your base class implement CommandBase, that way you have all the helpers methods.
@@ -32,6 +32,6 @@ There are many use cases where it makes sense to create a base class for your ot
 
 [Design your Command](Design_command.md)
 
-[Output to the Console guidline](ConsoleService.md)
+[Output to the Console guideline](ConsoleService.md)
 
 [Back to start](https://github.com/PowerCommands/PowerCommands2022/blob/main/Docs/README.md)

Docs/Configuration.md

@@ -28,16 +28,16 @@ Here you declare those dll components that the Core framework will use to find a
 Environment variables that the application needs to be aware about.
 
 ## Log
-Details about the loggning.
+Details about the logging.
 
 ## Metadata
 Description about your PowerCommand project.
 
 ## Repository
-URL to this repsository, used internally to create new VS solutions and Commands using PowerCommands applikation.
+URL to this repository, used internally to create new VS solutions and Commands using PowerCommands application.
 
 ## Secret
-Name of secrets that the application needs to be aware about, each secret has an corrensponding environment value that is encrypted.
+Name of secrets that the application needs to be aware about, each secret has an corresponding environment value that is encrypted.
 
 ## ShowDiagnosticInformation
 Enable or disable the display of diagnostic output.

Docs/ConsoleOutput.md

@@ -1,20 +1,20 @@
 # Display output to the console
 ## ConsoleService
-The output to the Console should almout always use the ConsoleService to print output out to the console, this could be done in diffrent ways.
+The output to the Console should almout always use the ConsoleService to print output out to the console, this could be done in different ways.
 ### Using the static service directly
 ![Alt text](images/ConsoleService.png?raw=true "Console Service")
 ### Using the Write helper methods in the [CommandBase](CommandBase.md) class
  - WriteCritical
- - WriteWarnig
+ - WriteWarning
  - WriteError
  - WriteLine
  - and so on...
 
 ## Why?
-The output will be displayed in a decided way, warnings wil have a certain color, diffrent from errors, and the output will be logged by default. And they will have log level corresponding to the type of output. WriteLine and Write have the options to be printed out to the console without being logged.
+The output will be displayed in a decided way, warnings wil have a certain color, different from errors, and the output will be logged by default. And they will have log level corresponding to the type of output. WriteLine and Write have the options to be printed out to the console without being logged.
 
 ### Exceptions
-There are situations where Console.Write or WriteLine is usefull, if you want to be sure that it will not be logged by misstake, the output of secrets for instance.
+There are situations where Console.Write or WriteLine is useful, if you want to be sure that it will not be logged by mistake, the output of secrets for instance.
 
 Read more about:
 

Docs/Create_new_ project.md

@@ -18,7 +18,7 @@ And this is what you should se!
 
 ![Alt text](images/DemoCommand.png?raw=true "Demo Command")
 
-Do not worry about all the drama that an empty demo input creates, the **demo** command demonstrates how you can use options to design your command and achive validation without the need for you to add validation code.
+Do not worry about all the drama that an empty demo input creates, the **demo** command demonstrates how you can use options to design your command and achieve validation without the need for you to add validation code.
 The demo command has an design attribute that looks something like this:
 
 ```

Docs/Create_new_command.md

@@ -3,7 +3,7 @@
 ## There is two ways of doing that, manually our let PowerCommand create one for you, using a template
 
 ### Manually
- Create a new class in the Commands directory or copy one existing and just rename it, a command that outputs "Hello World!" shoult look like this.
+ Create a new class in the Commands directory or copy one existing and just rename it, a command that outputs "Hello World!" should look like this.
 
 ``` 
 [PowerCommand(  description: "The Hello World classic!", example: "helloworld")]
@@ -19,7 +19,7 @@ public class HelloWorldCommand : CommandBase<PowerCommandsConfiguration>
 }
 ```
 
-When you start the PowerCommand applikcation and type
+When you start the PowerCommand application and type
 ```
 helloworld
 ```

Docs/Customize.md

@@ -3,11 +3,11 @@
 In your PowerCommands solution you have free hands to build you excellent CLI application, using the Core Framework together with your own homebrew code and code from others.
 Here is good things you need to know and think about.
 
-- Do not change code in the Core, use the recommended customizeble area insted, if you do change the core you may break compability and can not use the update functionallity because that will overwrite your changes.
-- If your business logic is generall and could be reused by many Commands projekct and maybe by other people, build a Custom Component.
-- In the bootstap project you can change some basic behaviour if you want.
+- Do not change code in the Core, use the recommended customizable area instead, if you do change the core you may break compatibility and can not use the update functionality because that will overwrite your changes.
+- If your business logic is general and could be reused by many Commands projekct and maybe by other people, build a Custom Component.
+- In the bootstrap project you can change some basic behavior if you want.
 - In the Commands project you can customize and extend the Configuration used by your Commands.
-- The class **PowerCommandServices.cs** loads basic services like the logging, the runtime and diagnostic handlar, here is the place to swap them if you feeling brave and adventurous.
+- The class **PowerCommandServices.cs** loads basic services like the logging, the runtime and diagnostic handler, here is the place to swap them if you feeling brave and adventurous.
 - **Startup.cs** is a good place to add code that you will run when the application starts.
 - **Program.cs** is the main entry for the application, feel free to add stuff here, se example below.
 
@@ -29,7 +29,7 @@ manager.Run(args);
 ```
 ## One more example, tweak the code completion preload of values.
 
-Open the **PowerCommandServices.cs** and you will find this code, where the codecompletion loads with name of the commands and existing suggestion defined in the [PowerCommandAttribute](PowerCommandAttribute.md)
+Open the **PowerCommandServices.cs** and you will find this code, where the code completion loads with name of the commands and existing suggestion defined in the [PowerCommandAttribute](PowerCommandAttribute.md)
 
 ```
 var suggestions = new List<string>(Runtime.CommandIDs);
@@ -41,6 +41,6 @@ Read more about:
 
 [Extend your configuration](ExtendYourConfiguration.md)
 
-[Design principles and guidlines](PowerCommands%20Design%20Principles%20And%20Guidlines.md)
+[Design principles and guidelines](PowerCommands%20Design%20Principles%20And%20Guidlines.md)
 
 [Back to start](https://github.com/PowerCommands/PowerCommands2022/blob/main/Docs/README.md)

Docs/Design_command.md

@@ -14,7 +14,7 @@ There are other ways you can solve the design to, you can solve it with two Comm
 
 ## Example code
 ### Use case
-You want a simple Command that converts a yaml file to json or xml format. Your first architecture descision is, one command or two? Well, it is a matter of taste but for this example the choise is one single command that handles the conversion to both formats. We use two [Options](Options.md), one for the filename, named path and one for the format named format. I exclude the implementation code to keep the code example short. We pretend that we have a static class handling this format conversions.
+You want a simple Command that converts a yaml file to json or xml format. Your first architecture decision is, one command or two? Well, it is a matter of taste but for this example the choice is one single command that handles the conversion to both formats. We use two [Options](Options.md), one for the filename, named path and one for the format named format. I exclude the implementation code to keep the code example short. We pretend that we have a static class handling this format conversions.
 
 ```
 using PainKiller.PowerCommands.Core.Extensions;
@@ -45,7 +45,7 @@ The new design look like this.
                           options: "!PATH|format",
                           example: "//Convert to json format|convert --path \"c:\\temp\\test.yaml\" --format json|//Convert to xml format|convert --path \"c:\\temp\\test.yaml\" --format xml")]
 ```                     
-Have a closer look at the !PATH option, it starts with a **!** and it consists of upperletter cases only **PATH**, with the use of the **!** sympol the option must have a value. With the use of uppercase letter the option it self is **mandatory**.  
+Have a closer look at the !PATH option, it starts with a **!** and it consists of upper letter cases only **PATH**, with the use of the **!** symbol the option must have a value. With the use of uppercase letter the option it self is **mandatory**.  
 
 If I run the command empty I trigger a validation error.
 
@@ -56,7 +56,7 @@ Lets have look of how the user input is designed.
 
 ![Alt text](images/Command_line_input_convert.png?raw=true "Describe convert command")
 
-This input will first be handled by the Core Framework, using the Identifier an instanse of the ConvertCommand will be created and the framework will also add the [Input](Input.md) instance to the ConvertCommand instans wich give your convert command two options named **path** and **format** to handle progamatically to create a file on the given path with the given format.
+This input will first be handled by the Core Framework, using the Identifier an instance of the ConvertCommand will be created and the framework will also add the [Input](Input.md) instance to the ConvertCommand instance which give your convert command two options named **path** and **format** to handle programmatically to create a file on the given path with the given format.
 
 # An alternative design using suggestions
 Instead of using the option **format** in the previous example you could use argument **xml** and **json** instead, there is nothing wrong or right here, it is up to you to choose what you think is the best approach.
@@ -94,10 +94,10 @@ public class ConvertCommand : CommandBase<PowerCommandsConfiguration>
     }
 }
 ```
-### **Please Note** that the name of the arguments in the design attribute is not important in code, it is usefull thou when help about the command is displayed. Suggestions is what it sounds like only suggestions to guide the user to the right input.
+### **Please Note** that the name of the arguments in the design attribute is not important in code, it is useful thou when help about the command is displayed. Suggestions is what it sounds like only suggestions to guide the user to the right input.
 
 ## Must I use the PowerCommandDesign attribute on every command I create?
-No that is not mandatory but it is recommended, note that when you declare the [Options](Options.md), they will be available for code completion, wich means that when the consumer types - and hit the tab button the user will can se what options there are that could be used, with a simple ! character you tell that the argument, quote, option or secret is required and then the Core runtime will validate that automatically for you.
+No that is not mandatory but it is recommended, note that when you declare the [Options](Options.md), they will be available for code completion, which means that when the consumer types - and hit the tab button the user will can se what options there are that could be used, with a simple ! character you tell that the argument, quote, option or secret is required and then the Core runtime will validate that automatically for you.
 
 Read more about CLI design here: [10 design principles for delightful CLIs](https://blog.developer.atlassian.com/10-design-principles-for-delightful-clis/)
 

Docs/DialogService.md

@@ -42,9 +42,6 @@ var password = DialogService.SecretPromptDialog("Enter secret:");
 ## QuestionAnswerDialog and YesNoDialog
 This dialog either prompt a question and returns the answer as an string or with the ```YesNoDialog``` prompts a question and returns a bool.
 
-
-
-
 Read more about:
 
 [Design your Command](Design_command.md)

Docs/DocumentationIndexDB.md

@@ -1,9 +1,9 @@
 # Documentation Index DB
 
 The Core framework uses a very simple Documentation Index that is stored as an json file named **DocsDB.data** in the **%USERNAME%\AppData\Roaming\PowerCommands** directory.
-You could also add new entries to this index if you want, prefered way is to use the **[DocCommand](https://github.com/PowerCommands/PowerCommands2022/blob/main/src/PainKiller.PowerCommands/PainKiller.PowerCommands.MyExampleCommands/Commands/DocCommand.cs)** and use this command.
+You could also add new entries to this index if you want, preferred way is to use the **[DocCommand](https://github.com/PowerCommands/PowerCommands2022/blob/main/src/PainKiller.PowerCommands/PainKiller.PowerCommands.MyExampleCommands/Commands/DocCommand.cs)** and use this command.
 
-The example adds a new Doc instans to the DocsDB with a link to google and some tags to it.
+The example adds a new Doc instance to the DocsDB with a link to google and some tags to it.
 ```
 doc "https://www.google.se/" --name Google-Search --tags tools,search,google
 ```
@@ -12,12 +12,12 @@ doc "https://www.google.se/" --name Google-Search --tags tools,search,google
 The DescribeCommand uses this DocsDB to find help for you, if you type anything that matches the name or a tag the application will open that URL for you, every page in this github documentation is added to this index.
 
 ## Update the DocsDB Index
-Easiest way is to start the applicatin from the bin folder, and use this command
+Easiest way is to start the application from the bin folder, and use this command
 ```
 powercommands update
 ```
 
-If you run the same command while debugging in Visual Studio the whole Core Framwork will be updated. (no harm doing that but you need to be aware of it)
+If you run the same command while debugging in Visual Studio the whole Core Framework will be updated. (no harm doing that but you need to be aware of it)
 The update will merge the content of your local stored file with the file on Github, so you do not lose your own added Docs.
 
 Read more about: