java - example - org.apache.commons jar

¿Puede el analizador de opciones de la CLI de Apache Commons ignorar las opciones de línea de comandos desconocidas?

Question

Estoy escribiendo una aplicación Java que toma argumentos de la línea de comandos que se procesan utilizando la CLI de Apache Commons con el GnuParser. Por razones que no son interesantes para entrar, me gustaría que ignorara silenciosamente las opciones de línea de comandos desconocidas en lugar de lanzar una excepción ParseException pero no veo una manera de hacerlo. Veo que hay una opción booleana stopAtNonOption en GnuParser.parse () pero lo que quiero es más como ignoreAtNonOption donde mantendrá las opciones de procesamiento después de encontrar un token desconocido.

Podría implementar mi propio analizador para lograr esto, pero me sorprende que no tenga esta funcionalidad incorporada, así que pensé en comprobarlo antes de seguir ese camino.

Código de ejemplo para lo que estoy hablando:

try {
  CommandLine commandLine = parser.parse(options, args);
  // stopAtNonOption set to true (below) is also not what I want
  // CommandLine commandLine = parser.parse(options, args, true);
} catch (ParseException e) {
  LOG.error("error parsing arguments", e);
  throw new RuntimeException(e);
}

Answer 1

Como se mencionó en un comentario, la solución aceptada no es más adecuada porque el método processOption ha sido desaprobado y eliminado.

Aquí está mi solución:

public class ExtendedParser extends DefaultParser {

    private final ArrayList<String> notParsedArgs = new ArrayList<>();

    public String[] getNotParsedArgs() {
        return notParsedArgs.toArray(new String[notParsedArgs.size()]);
    }

    @Override
    public CommandLine parse(Options options, String[] arguments, boolean stopAtNonOption) throws ParseException {
        if(stopAtNonOption) {
            return parse(options, arguments);
        }
        List<String> knownArguments = new ArrayList<>();
        notParsedArgs.clear();
        boolean nextArgument = false;
        for (String arg : arguments) {
            if (options.hasOption(arg) || nextArgument) {
                knownArguments.add(arg);
            } else {
                notParsedArgs.add(arg);
            }

        nextArgument = options.hasOption(arg) && options.getOption(arg).hasArg();
        }
        return super.parse(options, knownArguments.toArray(new String[knownArguments.size()]));
    }

}

En comparación con la solución propuesta por Pascal, también comprueba las opciones con argumentos y no mantiene los argumentos analizados en una lista separada.

Answer 2

Esto me funciona (también se pueden derivar otros analizadores):

public class ExtendedGnuParser extends GnuParser {

    private boolean ignoreUnrecognizedOption;

    public ExtendedGnuParser(final boolean ignoreUnrecognizedOption) {
        this.ignoreUnrecognizedOption = ignoreUnrecognizedOption;
    }

    @Override
    protected void processOption(final String arg, final ListIterator iter) throws     ParseException {
        boolean hasOption = getOptions().hasOption(arg);

        if (hasOption || !ignoreUnrecognizedOption) {
            super.processOption(arg, iter);
        }
    }

}

Answer 3

Esto no es posible con Commons CLI. Pero puede haber otra manera de lograr el resultado que espera si da más detalles de su caso de uso.

Answer 4

Soy un desarrollador muy malo, y hago esto para romper el código:

public class EasyPosixParser extends PosixParser {
    @Override
    protected void processOption(String arg, ListIterator iter) throws ParseException
    {
        try {
            super.processOption(arg, iter);
        } catch (ParseException e) {
            // do nothing
        }
    }
}

en su código principal, usted hace:

    CommandLineParser commandlineParser = new EasyPosixParser();