How to tell whether an option was given by user, or default was used? about spring-shell HOT 2 CLOSED

package com.example.spring.shell;

import org.springframework.shell.command.CommandRegistration;
import org.springframework.shell.command.parser.*;

import org.apache.commons.lang3.tuple.Pair;

import java.util.stream.Collectors;
import java.util.*;

/**
 * Class that parses a command; distinguishes the option given and its arguments.
 */
public class Parser {
    public static final String LONG_NAME_SYMBOL = "--";
    public static final String SHORT_NAME_SYMBOL = "-";

    private final Lexer.DefaultLexer lexer;

    /**
     * <p>Default constructor, prepares the lexer that parses the command.</p>
     * 
     * <p>
     *  Tokenize arguments and generate syntax tree results from tokens;
     *  result from it is then fed into the loop that visists the nodes.
     * </p>
     * 
     * @param command Command registration where parsing would occur.
     */
    public Parser(CommandRegistration) {
        var configuration = new ParserConfig();
        var registration  = Map.of(command.getCommand(), command);
        var model         = new CommandModel(registration, configuration);

        this.lexer = new Lexer.DefaultLexer(model, configuration);
    }

    /**
     * Generate syntax tree results from tokens; result from it is then fed into node visitor.
     * 
     * @param longs  Component long names to check against command options.
     * @param shorts Component short names to check against command options.
     * @param args   Raw arguments passed into an executing command.
     * @return {@code Pair} where the key is whether the option was selected in the command,
     * and the value is whether there were any argument values given.
     */
    public Pair<Boolean, Boolean> parse(String[] longs, Character[] shorts, String... args) {
        var list   = Arrays.asList(args);
        var ast    = new Ast.DefaultAst();
        var tokens = lexer.tokenize(list).tokens();
        var nodes  = ast.generate(tokens).nonterminalNodes();

        for (NonterminalAstNode ntn : nodes) {          // Loop through all command text nodes.
            if (ntn instanceof CommandNode cn) {        // Only proceed through command instance nodes.
                for (AstNode node : cn.getChildren()) { // Loop through children of the syntax tree nodes.
                    if (node instanceof OptionNode on && selected(longs, shorts, on.getName())) {
                        // Once an option node is found that was selected, return the appropriate result.
                        return Pair.of(true, on.getChildren().isEmpty());
                    }
                }
            }
        }

        // If option was not found within command, it means option was missing, and so were its arguments.
        return Pair.of(false, true);
    }

    /**
     * Validates whether the option was selected within the parser command.
     * 
     * @param longs  Array of long names to search through to see if one was selected.
     * @param shorts Array of short names to search through to see if one was selected.
     * @param name   Name given to match against within the long and short names.
     * @return True if match is found.
     */
    private boolean selected(String[] longs, Character[] shorts, String name) {
        if (name.startsWith(LONG_NAME_SYMBOL)) { // Search through long names if name is a long name.
            return Arrays.stream(longs).map(n -> LONG_NAME_SYMBOL + n).anyMatch(name::equals);
        } else if (name.startsWith(SHORT_NAME_SYMBOL)) { // Search through short names if name is a short name.
            var names  = Arrays.stream(shorts).map(n -> SHORT_NAME_SYMBOL + n).collect(Collectors.toSet());
            var length = name.length();
            if (length == 2) { // If simple singular short name.
                return names.contains(name);
            } else if (length > 2) { // If name is a compound short name (more than a character used -iv).
                for (int i = 1; i < length; i++) {
                    if (names.contains("-" + name.charAt(i))) return true;
                }
            }
        }

        return false; // No match found.
    }
}