CommandParser

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 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:

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

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:

-param1 -param2=valor --param3="Valor com espaços"

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"`

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:

--param="Este é um \"Valor\" com aspas internas"

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

Erros de Sintaxe

O parser lança uma exceção RFWValidationException 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.

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());
        }
    }
}

Resultado esperado no console:

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