Rodrigogml: Criou página com 'A classe `CommandParser` foi desenvolvida para realizar o parser de linhas de comando complexas. Ela é capaz de interpretar e separar corretamente argumentos e parâmetros, além de lidar com aspas simples e duplas, escapando os caracteres quando necessário. Seu objetivo é fornecer uma maneira eficiente de processar entradas em formato de linha de comando, separando os componentes e permitindo a fácil recuperação de argumentos e parâmetros com ou sem va...'

2024-09-08T20:20:57Z

Criou página com 'A classe <code>CommandParser</code> foi desenvolvida para realizar o parser de linhas de comando complexas. Ela é capaz de interpretar e separar corretamente argumentos e parâmetros, além de lidar com aspas simples e duplas, escapando os caracteres quando necessário. Seu objetivo é fornecer uma maneira eficiente de processar entradas em formato de linha de comando, separando os componentes e permitindo a fácil recuperação de argumentos e parâmetros com ou sem va...'

Página nova

A classe <code>CommandParser</code> foi desenvolvida para realizar o parser de linhas de comando complexas. Ela é capaz de interpretar e separar corretamente argumentos e parâmetros, além de lidar com aspas simples e duplas, escapando os caracteres quando necessário. Seu objetivo é fornecer uma maneira eficiente de processar entradas em formato de linha de comando, separando os componentes e permitindo a fácil recuperação de argumentos e parâmetros com ou sem valores atribuídos.

= Formatos de Argumentos, Parâmetros e Valores =

== Argumentos ==
Os argumentos são definidos como partes da linha de comando que não são precedidas por `-` ou `--`. Eles podem ser colocados livremente na linha de comando e são capturados pela classe como uma lista simples de strings. Além disso, os argumentos podem ser delimitados por aspas (simples ou duplas), permitindo a inclusão de espaços dentro de um único argumento.

'''Exemplo de argumentos''':
<syntaxhighlight lang="java">
arg1 arg2 "Um argumento extra com espaços!" arg3
</syntaxhighlight>

Neste exemplo, os argumentos seriam separados como:

* `arg1`
* `arg2`
* `"Um argumento extra com espaços!"`
* `arg3`

== Parâmetros ==
Os parâmetros são precedidos por `-` ou `--` e podem ou não ter valores atribuídos. Caso um valor seja atribuído, ele deve ser separado do parâmetro pelo caractere `=`. Parâmetros sem valores são interpretados como `null`.

'''Exemplo de parâmetros''':
<syntaxhighlight lang="java">
-param1 -param2=valor --param3="Valor com espaços"
</syntaxhighlight>

Neste exemplo, a classe captura os seguintes parâmetros:

* `-param1` sem valor presente
* `-param2` com o valor `"valor"`
* `--param3` com o valor `"Valor com espaços"`

{{nota|Parâmetros sem Valor|Quando nenhum valor é definido explicitamente para o parâmetro, o parser atribui o valor "true" (em String), como se estivesse sendo habilitado somente pela presença na linha de comando.}}

== Aspas e Caracteres Escapados ==
Aspas simples (`'`) ou duplas (`"`) são usadas para delimitar valores de parâmetros que contenham espaços ou outros caracteres especiais. Dentro dessas aspas, é possível usar o caractere de escape (`\`) para incluir o próprio delimitador de aspas no valor.

'''Exemplo com aspas e escape''':
<syntaxhighlight lang="java">
--param="Este é um \"Valor\" com aspas internas"
</syntaxhighlight>

Neste caso, o valor do parâmetro será: `Este é um "Valor" com aspas internas`.

== Erros de Sintaxe ==
O parser lança uma exceção <code>[[RFWValidationException]]</code> quando há um erro de estrutura na linha de comando, como aspas desbalanceadas ou parâmetros malformados.

= Como Usar =

A seguir, um exemplo de como utilizar a classe `CommandParser` para fazer o parser de uma linha de comando fictícia. O código abaixo demonstra como capturar e processar argumentos e parâmetros de uma linha de comando complexa.

<syntaxhighlight lang="java">
public class Main {
public static void main(String[] args) throws RFWException {
String cmd = "arg1 arg2 \"Um argumento extra com espaços!\" arg3 -param1 -param2=valor --param3 = \"Esse é um \\\"Valor\\\" do param3\" arg4 -param5= 'Este é outro \\'tipo de valor com Scape\\' de aspas e outras \" no conteúdo interno do texto'";
CommandParser.ParsedCommand result = CommandParser.parse(cmd);

// Imprime os argumentos
for (String arg : result.arguments) {
System.out.println("Arg: " + arg);
}

// Imprime os parâmetros e valores
for (Map.Entry<String, String> entry : result.parameters.entrySet()) {
System.out.println("Param: " + entry.getKey() + " / Value: " + entry.getValue());
}
}
}
</syntaxhighlight>

'''Resultado esperado no console:'''
<pre>
Arg: arg1
Arg: arg2
Arg: Um argumento extra com espaços!
Arg: arg3
Arg: arg4
Param: -param1 / Value: null
Param: -param2 / Value: valor
Param: --param3 / Value: Esse é um "Valor" do param3
Param: -param5 / Value: Este é outro 'tipo de valor com Scape' de aspas e outras " no conteúdo interno do texto
</pre>

CommandParser - Histórico de revisão