Merge branch 'master' of https://github.com/juniorgasparotto/syscommand

documentation/.generator/pages/presentation/how-it-works.md

@@ -2,11 +2,17 @@
 
 Ele funciona como um analisador automatizado de linha de comando, permitindo que o programador se concentre nas regras de negócios de sua aplicação.
 
+Para isso, você pode escolher 3 maneiras de trabalho:
+
+* Método **Main tipado**: Equivale ao modelo tradicional `Main(string[] args)`, mas de forma tipada.
+* **Propriedades**: Cada propriedade será transformada em argumentos.
+* **Métodos**: Cada método será transformado em um sub-comando: **Ação**
+
 Além disso, ele dispõe de um recurso para simular um prompt de comando dentro do proprio Visual Studio, eliminando a necessidade de testar sua aplicação fora do ambiente de desenvolvimento.
 
 Outros recursos essênciais como `help`, `verbose`, `error handling` e outros também são suportados.
 
-**Exemplo simples:**
+**Exemplo de `Main-typed`:**
 
 ```csharp
 namespace Example.Initialization.Simple
@@ -25,53 +31,113 @@ namespace Example.Initialization.Simple
     // and its public properties and methods will be available for use.
     public class MyCommand : Command
     {
-        public string MyProperty { get; set; }
-
-        // This signature "Main()" is reserved to process arguments/properties.
-        public void Main()
+        // This signature "Main(...)" is reserved to process arguments fastly.
+        public void Main(string myArgument, int? myArgument2 = null)
         {
-            // verify if property was inputed by user.
-            if (MyProperty != null)
-            {
-                this.App.Console.Write(string.Format("Main MyProperty='{0}'", MyProperty));
-            }
-        }
+            // this arg is obrigatory
+            this.App.Console.Write(string.Format("myArgument='{0}'", myArgument));
 
-        public void MyAction(bool a)
-        {
-            this.App.Console.Write(string.Format("MyAction a='{0}'", a));
+            // verify if property was inputed by user.
+            if (myArgument2 != null)
+                this.App.Console.Write(string.Format("myArgument2='{0}'", myArgument2));
         }
     }
 }
 ```
 
-**Testes no prompt de comando:**
+_Testes em um prompt externo:_
 
 ```
 C:\Users\MyUser> MyApp.exe help
 ... the automatic help text will be shown ...
 
-C:\Users\MyUser> MyApp.exe --my-property value
-Main MyProperty='value'
+C:\Users\MyUser> MyApp.exe --my-argument "value"
+myArgument='value'
 
-C:\Users\MyUser> MyApp.exe my-action -a
-MyAction a='True'
+C:\Users\MyUser> MyApp.exe --my-argument "value" --my-argument2 1000
+myArgument='value'
+myArgument2='1000'
 ```
 
-**Testes no Visual Studio usando o simulador de console:**
+_Testes no Visual Studio usando o simulador de console:_
 
 ```
 cmd> help
 ... the automatic help text will be shown ...
 
-cmd> --my-property value
-Main MyProperty='value'
+cmd> --my-argument "value"
+myArgument='value'
+
+cmd> --my-argument "value" --my-argument2 1000
+myArgument='value'
+myArgument2='1000'
+```
+
+**Exemplo de uso com propriedades:**
+
+```csharp
+namespace Example.Initialization.Simple
+{
+    using SysCommand.ConsoleApp;
+
+    public class Program
+    {
+        public static int Main(string[] args)
+        {
+            return App.RunApplication();
+        }
+    }
+
+    public class MyCommand : Command
+    {
+        public string MyArgument { get; set; }
 
+        // This signature "Main()" is reserved to process properties.
+        public void Main()
+        {
+            if (MyArgument != null)
+                this.App.Console.Write(string.Format("Main MyArgument='{0}'", MyArgument));
+        }
+    }
+}
+```
+
+```
+cmd> --my-argument value
+Main MyArgument='value'
+```
+
+**Exemplo de ações:**
+
+```csharp
+namespace Example.Initialization.Simple
+{
+    using SysCommand.ConsoleApp;
+
+    public class Program
+    {
+        public static int Main(string[] args)
+        {
+            return App.RunApplication();
+        }
+    }
+
+    public class MyCommand : Command
+    {
+        public void MyAction(bool a)
+        {
+            this.App.Console.Write(string.Format("MyAction a='{0}'", a));
+        }
+    }
+}
+```
+
+```
 cmd> my-action -a
 MyAction a='True'
 ```
 
-**_Note que não existe nenhum código de parse, seu código está limpo e pronto para receber comandos._**
+**_Note que não existe nenhum código de analise em nenhum exemplo, seu código está limpo e pronto para receber comandos._**
 
 ### Entenda melhor...
 
@@ -81,31 +147,31 @@ Tecnicamente, existem quatro entidades de domínio que são a base do framework:
 
 É o contexto da aplicação, onde uma `App` contém diversos `Commands`. É representada pela classe `SysCommand.ConsoleApp.App` e deve ser a primeira entidade a ser configurada em seu método `Main(string[] args)`.
 
-A inicialização do contexto da aplicação pode ser feita de duas formas, por uma instância da class `App` ou através do método estático `App.RunApplication` que fornece um recurso de simulação de console que ajuda você a testar seus inputs dentro do próprio Visual Studio, sem a necessidade de executar seu ".exe" em um console externo, basta apertar o _Play_. Veja <anchor-get name="class-app" /> e <anchor-get name="initializing-by-static-method" />.
+A inicialização do contexto da aplicação pode ser feita de duas formas, por uma instância da class `App` ou através do método estático `App.RunApplication` que fornece um recurso de simulação de console que ajuda você a testar seus inputs dentro do próprio Visual Studio, sem a necessidade de executar seu ".exe" em um console externo, basta apertar o _Play_. Saiba mais: <anchor-get name="class-app" /> , <anchor-get name="initializing-by-static-method" />.
 
 **`Command`**
 
 Os comandos representam um agrupamento de funcionalidades do mesmo contexto de negócio, similar aos _Controllers do MVC_. Programaticamente eles são representadas por classes que herdam de `SysCommand.ConsoleApp.Command`. Cada instância de `Command` terá acesso ao contexto corrente pela propriedade `this.App`.
 
-Por padrão, o sistema tenta encontrar, de forma automática, qualquer classe que extenda de `Command`, sendo assim não é necessário especifica-los na inicializaçao, embora isso seja possível. Veja <anchor-get name="kind-of-commands" /> e <anchor-get name="specifying-commands" />.
+Por padrão, o sistema tenta encontrar, de forma automática, qualquer classe que extenda de `Command`, sendo assim não é necessário especifica-los na inicializaçao, embora isso seja possível. Saiba mais: <anchor-get name="kind-of-commands" /> , <anchor-get name="specifying-commands" />.
 
 **`Argument`**
 
 Os argumentos representam o meio mais básico de uma aplicação console, são os conhecidos `--argument-name value`, `-v` e etc. Programaticamente eles são representados pelas _propriedades_ do `Command` e devem ser acompanhados de um método chamado `Main()` (sem parâmetros) para poder interceptar se uma propriedade foi ou não utilizada. O nome `Main` foi escolhido pela similaridade de conceito com o método `Main(string[] args)` do .NET.
 
 Do lado do usuário, nenhuma sintaxe especial foi criada, os padrões mais conhecidos foram implementados. Os argumentos longos são acessados com o prefixo `--` e são acompanhados do nome do argumento. Os argumentos curtos são acessados com um traço `-` ou uma barra `/` e são acompanhados de apenas um caracter. Os valores dos argumentos devem estar na frente do nome do argumento separados por um espaço ` ` ou `:` ou `=`. Inputs posicionais também são suportados, possibilitando a omissão do nome do argumento.
 
-Por padrão, todas as propriedades publicas de seu `Command` serão habilitadas para serem `arguments`. Veja <anchor-get name="properties" />, <anchor-get name="properties-ignore-public" />, <anchor-get name="input" /> e <anchor-get name="support-types" />.
+Por padrão, todas as propriedades publicas de seu `Command` serão habilitadas para serem `arguments`. Saiba mais: <anchor-get name="properties" />, <anchor-get name="properties-ignore-public" />, <anchor-get name="input" />, <anchor-get name="support-types" />.
 
 **`Action`**
 
 Representam ações iguais as _Actions dos Controllers do MVC_. Programaticamente representam os _métodos_ do `Command` e seus parâmetros (se existir) serão convertidos em `arguments` e que só serão acessados quando acompanhados do nome da ação.
 
 Seu uso é similar ao modo como usamos os recursos do `git` como: `git add -A`; `git commit -m "comments"`, onde `add` e `commit` seriam o nome das ações e `-A`, `-m` seus respectivos argumentos.
 
-Ainda é possível omitir o nome da ação no input do usuário. Esse recurso é chamado de `Método Padrão` e se assemelha muito com o uso de propriedades.
+Ainda é possível omitir o nome da ação no input do usuário. Esse recurso é chamado de **Método Padrão** e se assemelha muito com o uso de propriedades.
 
-Por padrão, todos os métodos publicos de seu `Command` serão habilitadas para serem `actions`. Veja <anchor-get name="methods" />, <anchor-get name="methods-ignore-public" /> e <anchor-get name="methods-default" />.
+Por padrão, todos os métodos publicos de seu `Command` serão habilitadas para serem `actions`. Saiba mais: <anchor-get name="methods" />, <anchor-get name="methods-ignore-public" />, <anchor-get name="methods-default" />.
 
 **Exemplo avançado:**
 
@@ -299,13 +365,13 @@ Commit
 
 **Saiba mais...**
 
-* Note que os tipos primitivos de cada propriedade estão configurados como `Nullable`. Isso é importante para ter condições de identificar que o usuário inseriu uma determinada propriedade. Veja <anchor-get name="properties" />.
+* Note que os tipos primitivos de cada propriedade estão configurados como `Nullable`. Isso é importante para ter condições de identificar que o usuário inseriu uma determinada propriedade. Saiba mais: <anchor-get name="properties" />.
 * Todos os tipos primitivos do .NET, Enums, Enums Flags e Collections são suportados. Veja o tópico de <anchor-get name="support-types" />.
-* Use `App.Console.Write()`, `App.Console.Error()` (entre outros) para imprimir seus outputs e usufruir de recursos como o `verbose`. Veja <anchor-get name="verbose" />.
-* Você pode utilizar o retorno dos métodos como `output`, inclusive o método reservado `Main()`. Ou use `void` se não quiser usar esse recurso. Veja <anchor-get name="output" />.
-* Se desejar, customize seus `arguments` ou `actions` usando os atributos `ArgumentAttribute` e `ActionAttribute`. Você pode customizar diversos atributos como nomes, texto de ajuda e dentro outros. Veja <anchor-get name="properties-customizing-name" /> e <anchor-get name="methods-customizing-names" />.
-* Você pode usar métodos com o mesmo nome (sobrecargas) para definir diferentes `actions`. Elas podem ser chamadas no prompt de comando com o mesmo nome, mas os argumentos definirão qual o método a ser chamado, igual ocorre em `c#`. Veja <anchor-get name="methods-overloads" />
+* Use `App.Console.Write()`, `App.Console.Error()` (entre outros) para imprimir seus outputs e usufruir de recursos como o `verbose`. Saiba mais: <anchor-get name="verbose" />.
+* Você pode utilizar o retorno dos métodos como `output`, inclusive o método reservado `Main()`. Ou use `void` se não quiser usar esse recurso. Saiba mais: <anchor-get name="output" />.
+* Se desejar, customize seus `arguments` ou `actions` usando os atributos `ArgumentAttribute` e `ActionAttribute`. Você pode customizar diversos atributos como nomes, texto de ajuda e dentro outros. Saiba mais: <anchor-get name="properties-customizing-name" /> e <anchor-get name="methods-customizing-names" />.
+* Você pode usar métodos com o mesmo nome (sobrecargas) para definir diferentes `actions`. Elas podem ser chamadas no prompt de comando com o mesmo nome, mas os argumentos definirão qual o método a ser chamado, igual ocorre em `c#`. Saiba mais: <anchor-get name="methods-overloads" />
 * Opte por usar o método `int Program.Main(string[] args)` com retorno, assim você pode retornar o status code para o console. (ERROR=1 ou SUCCESS=0).
-* Existe também o suporte nativo para gerar o texto de ajuda. Veja <anchor-get name="help" />.
+* Existe também o suporte nativo para gerar o texto de ajuda. Saiba mais: <anchor-get name="help" />.
 
 Esse foi apenas um resumo, para conhecer mais sobre esse projeto veja a nossa <anchor-get name="documentation" />.

documentation/en.md

@@ -82,7 +82,7 @@ public App(
 ```
 
 * `commandsTypes`: Specifies the `Command` types that will be used throughout the process. If it is `null` then the system will try to automatically any class that extend from `Command` . Understand better in [Specifying the types of commands](https://github.com/juniorgasparotto/SysCommand/blob/master/documentation/en.md#specifying-commands).
-* `enableMultiAction`: Turns the `MultiAction` behavior. By default, this behavior will be enabled. Understand better in [Multi-action](https://github.com/juniorgasparotto/SysCommand/blob/master/documentation/en.md#using-the-multi-action-feature).
+* `enableMultiAction`: Turns the `MultiAction` behavior. By default, this behavior is enabled. Understand better in [Multi-action](https://github.com/juniorgasparotto/SysCommand/blob/master/documentation/en.md#using-the-multi-action-feature).
 * `addDefaultAppHandler`: If `false` so does not create the event handler that is responsible for the `outputs` standard engine and `erros` controls, and among others. The default is `true` . Understand better in [Event control](https://github.com/juniorgasparotto/SysCommand/blob/master/documentation/en.md#events).
 
 ## <a name="initializing-by-static-method" />Booting with the console Simulator

documentation/pt-br.md

@@ -82,7 +82,7 @@ public App(
 ```
 
 * `commandsTypes`: Especifica os tipos dos `Command` que serão utilizados em todo o processo. Caso seja `null` então o sistema buscará automáticamente qualquer classe que extenda de `Command`. Entenda melhor em [Especificando os tipos de comandos](https://github.com/juniorgasparotto/SysCommand/blob/master/documentation/pt-br.md#specifying-commands).
-* `enableMultiAction`: Liga ou desliga o comportamento de `MultiAction`. Por padrão, esse comportamento estará habilidado. Entenda melhor em [Multi-action](https://github.com/juniorgasparotto/SysCommand/blob/master/documentation/pt-br.md#using-the-multi-action-feature).
+* `enableMultiAction`: Liga ou desliga o comportamento de `MultiAction`. Por padrão, esse comportamento estará habilitado. Entenda melhor em [Multi-action](https://github.com/juniorgasparotto/SysCommand/blob/master/documentation/pt-br.md#using-the-multi-action-feature).
 * `addDefaultAppHandler`: Caso seja `false` então NÃO cria o handler de eventos que é responsável pelo mecanismo padrão de `outputs` e controles de `erros` e dentre outros. O padrão é `true`. Entenda melhor em [Controle de eventos](https://github.com/juniorgasparotto/SysCommand/blob/master/documentation/pt-br.md#events).
 
 ## <a name="initializing-by-static-method" />Inicializando com o simulador de console