refactoring

Author: PowerCommands

Docs/Design_command.md

@@ -1,20 +1,20 @@
 # Design your command
 
-Think of your command as an one line command with some parameters in a cmd prompt environment, it should do a small amount of isolated task in a specific context, for example lets say you want to convert yaml file to json or xml. A good name could be **ConvertCommand**, as parameters you have a path to the input file, and a flag for the format and a value to that flag. That is a pretty good design for one Command. 
+Think of your command as an one line command with some parameters in a cmd prompt environment, it should do a small amount of isolated task in a specific context, for example lets say you want to convert yaml file to json or xml. A good name could be **ConvertCommand**, as parameters you have a path to the input file, and a O for the format and a value to that option. That is a pretty good design for one Command. 
 
  The usage of this command will look like this if I want to convert my yaml fil to json.
 
 ```convert "C:\temp\myYaml.yaml" --format json```
 
-If you want the input to be more self described, which the framework encourages you to do for clarity, you can choose to add a flag for the filepath like this:
+If you want the input to be more self described, which the framework encourages you to do for clarity, you can choose to add a option for the filepath like this:
 
 ```convert --file "C:\temp\myYaml.yaml" --format json```
 
 There are other ways you can solve the design to, you can solve it with two Commands instead, one command named **XmlCommand** and another named **JsonCommand**, it is all up to you.
 
 ## 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 [Flags](Flags.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 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.
 
 ```
 using PainKiller.PowerCommands.Core.Extensions;
@@ -23,23 +23,23 @@ using PainKiller.PowerCommands.MyExampleCommands.Configuration;
 namespace PainKiller.PowerCommands.MyExampleCommands.Commands;
 
 [PowerCommandDesign(  description: "Converting yaml format to json or xml format",
-                            flags: "path|format",
+                          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")]
 public class ConvertCommand : CommandBase<PowerCommandsConfiguration>
 {
     public ConvertCommand(string identifier, PowerCommandsConfiguration configuration) : base(identifier, configuration) { }
 
     public override RunResult Run()
     {
-        YamlFormatManger.Convert(Input.GetFlagValue("path"), Input.GetFlagValue("format"));
+        YamlFormatManger.Convert(Input.GetOptionValue("path"), Input.GetOptionValue("format"));
         return Ok();
     }
 }
 ```
-Notice that the documentation for how this command will be used is created with the [PowerCommandDesign](PowerCommandDesignAttribute.md) attribute. I realize that the path flag should be required, I can of course code this check in the Command but I do not need to do that, instead I declare that with the [PowerCommandDesign](PowerCommandDesignAttribute.md) attribute, I just add a **!** before the path flag, this will be validated before the execution of the run command. The new design look like this.
+Notice that the documentation for how this command will be used is created with the [PowerCommandDesign](PowerCommandDesignAttribute.md) attribute. I realize that the path option should be required, I can of course code this check in the Command but I do not need to do that, instead I declare that with the [PowerCommandDesign](PowerCommandDesignAttribute.md) attribute, I just add a **!** before the path option, this will be validated before the execution of the run command. The new design look like this.
 ```
 [PowerCommandDesign(  description: "Converting yaml format to json or xml format",
-                            flags: "!path|format",
+                            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")]
 ```                     
 If I run the command empty I trigger a validation error.
@@ -51,10 +51,10 @@ 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 flags 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 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.
 
 ## 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 [Flags](Flags.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 flags there are that could be used, with a simple ! character you tell that the argument, quote, flag or secret is required and then the Core runtime will validate that automatically for you. That is really nice, you could read more about design of good Command Line Inter fade design here:
+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. That is really nice, you could read more about design of good Command Line Inter fade design here:
 
 Next step is to understand the [Power Commands Design attribute](PowerCommandDesignAttribute.md)
 
@@ -65,6 +65,6 @@ Read more about:
 
 [Input](Input.md)
 
-[Flags](Flags.md)
+[Options](Options.md)
 
 [Back to start](https://github.com/PowerCommands/PowerCommands2022/blob/main/Docs/README.md)

Docs/Input.md

@@ -10,7 +10,7 @@ public interface ICommandLineInput
     string Identifier { get; init; }
     string[] Quotes { get; init; }
     string[] Arguments { get; init; }
-    string[] Flags { get; init; }
+    string[] options { get; init; }
     string SingleArgument { get; }
     string SingleQuote { get; }
     string? Path { get; init; }
@@ -31,15 +31,15 @@ It could look something like this.
 ```
 public override RunResult Run()
 {
-    if(Input.HasFlag("hello")) WriteLine("Hello World!");
+    if(Input.HasOption("hello")) WriteLine("Hello World!");
     return CreateRunResult();
 }
 ```
 
 ## Properties and it´s usage
 For this example let´s imagine the user has typed in the following input in the console.
 
-``` demo argumentOne "This is a qoute" --demo myFlagValue ```
+``` demo argumentOne "This is a qoute" --demo myOptionValue ```
 
 ### Raw
 The raw input as it was typed by the user in the Console.
@@ -49,16 +49,16 @@ The Id of the command it is the first argument that the user types, the id is th
 All input strings surrounded with " (quotation mark) in this example it is one quote with the value **"This is a quote"** (This value will be returned by the **SingleQuote** property)
 ### Arguments
 All input strings not surrounded with " except for the first one (wich is the Identifier) and every argument starting with -- marks in the example it is one argument with the value **argumentOne** (This value will be returned by the **SingleArgument** property)
-### Flags
-All arguments that is staring with the -- marks is considered as flags, and ever argument after the flag is considered as that flags value, in the example the flag **demo** has the value **myFlagValue** a flag must not have a value.
+### Options
+All arguments that is staring with the -- marks is considered as options, and ever argument after the option is considered as that options value, in the example the option **demo** has the value **myOptionValue** a option must not have a value.
 ### Path
 The path is a special value if your command only should have an input that is a path, then it is usefull, you do not need to input the path in quotation marks even if it contains blank space.
 
 Read more about:
 
 [Design your Command](Design_command.md)
 
-[Flags](Flags.md)
+[Options](Options.md)
 
 [PowerCommands Attribute](PowerCommandAttribute.md)
 

Docs/Options.md

@@ -5,7 +5,7 @@ Options is what the name implies, options for your command, lets have a look at
 
 You could also se that this Command has two options separated with pipe **"mode|name"**, first one named **mode** and the other one is **name**. This will give the user autocomplete feedback when typing - and using the [Tab] tangent.
 
-Programatically you can use Options in two ways, you could grab the value, wich is the parameter typed after the flag, like this (using the RegressionCommand as example, it is a user created command).
+Programatically you can use Options in two ways, you could grab the value, wich is the parameter typed after the option, like this (using the RegressionCommand as example, it is a user created command).
 
 ``` regression --mode normal --name "My sample project" ```
 

Docs/PowerCommandDesignAttribute.md

@@ -5,7 +5,7 @@ This is easy with the usage of the PowerCommandsAttribute, just apply them on th
 
 Now lets take a practical example...
 ## Use case
-You want to create a simple Command that converts a yaml file to json or xml format. Your choose to solve this with one Command that handles both this formats, you will use flags. You can read more about how the class will look like here: [Design your command](Design_command.md)
+You want to create a simple Command that converts a yaml file to json or xml format. Your choose to solve this with one Command that handles both this formats, you will use options. You can read more about how the class will look like here: [Design your command](Design_command.md)
 
 This is how the PowerCommandAttribute look like, to help the user consume this command.
 
@@ -15,7 +15,7 @@ When the user running this applikcation and wants to now more about the Convert
 
 ```describe convert```
 
-Or use the help flag
+Or use the help option
 ```convert --help```
 
 And this help will be displayed:
@@ -25,15 +25,15 @@ And this help will be displayed:
 ### A clooser look on the syntax
 ```
 [PowerCommandDesign(  description: "Converting yaml format to json or xml format",
-                flags: "!path|format",
+                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")]
 ```
 The user can use this command like this (note that argument and quotes are not described in the attribute beacause this command do not use them):
 
 ![Alt text](images/Command_line_input_described.png?raw=true "Describe convert command")
 
-## Mark argument, quote, flag or secret as required with **!** character
-If you look close at the example above you see two **flags** are declared like this **!path** and **format** the **!** character before the flag name tells the Core Runtime that this flag requires a value and it will be validated before the command Run methods executes, if he user ommits the **path** flag value this will occur:
+## Mark argument, quote, option or secret as required with **!** character
+If you look close at the example above you see two **options** are declared like this **!path** and **format** the **!** character before the option name tells the Core Runtime that this option requires a value and it will be validated before the command Run methods executes, if he user ommits the **path** option value this will occur:
 
 ![Alt text](images/convert_validation_error.png?raw=true "Describe convert command")
 
@@ -44,9 +44,9 @@ Describe your arguments, separate them with | use // to display a commented line
 Describe your quotes, separate them with | use // to display a commented line over the actual quote.
 ### suggestion
 Suggestion will be added to the autocomplete functionallity so the user could use tab to cycle trough the commands and commands with a suggested argument.
-### flags
-Describe your flags, separate them with | use // to display a commented line over the actual flag, all flags that are described will also be used by the autocomplete functionallity to help the user find the right flag.
-Read more about [Flags](Flags.md).
+### Options
+Describe your options, separate them with | use // to display a commented line over the actual option, all options that are described will also be used by the autocomplete functionallity to help the user find the right option.
+Read more about [options](options.md).
 ### secrets
 Describe your secrets that the commands needs, you probably want to declare a secret as required with **!** character, in the sample above secret **cnDatabase** is marked as required.
 ```
@@ -59,7 +59,7 @@ Read more about how to manage [Secrets](Secrets.md).
 Describe examples on how to use the command, separate them with | use // to display a commented line over the actual example.
 
 ### Separator and comments
-Flags, quotes, arguments and example all have a property on the PowerCommandAttribute, each item are separeted with | and if you want to put a comment row before your item add this with the prefix //, if you look at the example it is used to describe two examples of usage.
+options, quotes, arguments and example all have a property on the PowerCommandAttribute, each item are separeted with | and if you want to put a comment row before your item add this with the prefix //, if you look at the example it is used to describe two examples of usage.
 
 example: "**//Convert to json format**|convert --path \"c:\\temp\\test.yaml\" --format json|**//Convert to xml format**|convert --path \"c:\\temp\\test.yaml\" 
 
@@ -71,6 +71,6 @@ Read more about:
 
 [Input](Input.md)
 
-[Flags](Flags.md)
+[options](options.md)
 
 [Back to start](https://github.com/PowerCommands/PowerCommands2022/blob/main/Docs/README.md)

Docs/PowerCommands Design Principles And Guidlines.md

@@ -29,7 +29,7 @@
 * [Use Markdown format](#UseMarkdownformat)
 * [Always describe your PowerCommands](#AlwaysdescribeyourPowerCommands)
 * [Use PowerCommand attribute](#UsePowerCommandattribute)
-* [Flags](#Flags)
+* [options](#options)
 
 <!-- vscode-markdown-toc-config
 	numbering=false
@@ -192,13 +192,13 @@ You have two options
  ```powercommand update``` and then reload the solution
 
 ## <a name='DesignofyourCommands'></a>Design of your Commands
- Think of your command as an one line command with some parameters in a cmd prompt environment, it should do a single isolated task, for example lets say you want to convert yaml file to json or xml. A good name could be **ConvertCommand**, as parameters you have a path to the input file, and a flag for the format and a value to that flag. That is a pretty good design for one Command. 
+ Think of your command as an one line command with some parameters in a cmd prompt environment, it should do a single isolated task, for example lets say you want to convert yaml file to json or xml. A good name could be **ConvertCommand**, as parameters you have a path to the input file, and a option for the format and a value to that option. That is a pretty good design for one Command. 
 
  The usage of this command will look like this if I want to convert my yaml fil to json.
 
 ```convert "C:\temp\myYaml.yaml" --format json```
 
-If you want the input to be more self described, which the framework encourages you to do for clarity, you can choose to add a flag for the filepath like this:
+If you want the input to be more self described, which the framework encourages you to do for clarity, you can choose to add a option for the filepath like this:
 
 ```convert --file "C:\temp\myYaml.yaml" --format json```
 
@@ -332,14 +332,14 @@ In such cases they should support the identical configuration structure otherwis
 This is an example where every property of the attributes is used
 
 ![Alt text](images/attributes.png?raw=true "Attributes")
-Attributes is used to show a nice description of the command with the built in --help flag. 
+Attributes is used to show a nice description of the command with the built in --help option. 
 
 ```
 regression --help
 ```
-![Alt text](images/power_command_attribute.png?raw=true "Usage of help flag")
+![Alt text](images/power_command_attribute.png?raw=true "Usage of help option")
 
-But it is just not for displaying the help, the flag property and the suggestion property of the PowerCommandAttribute controls suggestions provided by intellisense, you should really take advantage of that.
+But it is just not for displaying the help, the option property and the suggestion property of the PowerCommandAttribute controls suggestions provided by intellisense, you should really take advantage of that.
 
 ## <a name='Options'></a>Options
 In the example image showing usage of the attributes you could se that the options: property is set to **"mode|name"**, that means that this command has two option one named **mode** and the other one is **name**. This will give the user autocomplete feedback when typing - and using the [Tab] tangent.