More descriptive error message when required option is not present

[markpollack]

As an example, the command

	@ShellMethod(key = "catalog add", value = "Add a project to a project catalog")
	public void catalogAdd(
			@ShellOption(help = "Catalog name", arity = 1) String name,
			@ShellOption(help = "Catalog url", arity = 1) String url,
			@ShellOption(help = "Catalog description", defaultValue = ShellOption.NULL, arity = 1) String description,
			@ShellOption(help = "Project tags", defaultValue = ShellOption.NULL, arity = 1) List<String> tags
	) {

when the name option is not specified

spring:>catalog add --url https://github.com/rd-1-2022/spring-gs-catalog
Missing option, longnames='name', shortnames=''

It would also be useful to use the help message to help convey the missing option to the user. The use of longnames and shortnames is also sort of confusing as they are terms only know to those very familiar with the implementation of the shell when using the DSL and those terms are not used in the annotation programming model, and not exposed to the end user at all.

Something along the lines of

spring:>catalog add --url https://github.com/rd-1-2022/spring-gs-catalog
Missing mandatory option "--name", Catalog name.  Use the command "help catalog add" for additional information on command options

[jvalkeal]

I've been thinking about this some time now and it needs a change as it's a bit weird. What I also wanted to do is making it configurable both globally and on a command level as well.

[berttty]

Hi @markpollack and @jvalkeal:

I had the same problem, and I solved it following the steps below:

NOTE: The Spring-shell version was 2.0.0

1. Create a class that extends TerminalAwareResultHandler<ParameterMissingResolutionException>; the vital part is the class ParameterMissingResolutionException because this provides you with the parameter information and, most of all, the context.

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import org.jline.utils.AttributedString;
import org.jline.utils.AttributedStyle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.shell.CommandRegistry;
import org.springframework.shell.ParameterMissingResolutionException;
import org.springframework.shell.result.TerminalAwareResultHandler;
import org.springframework.shell.standard.ShellMethod;
import org.springframework.util.ReflectionUtils;

public class ParameterMissingResultHandler extends TerminalAwareResultHandler<ParameterMissingResolutionException> {

  @Autowired
  @Lazy
  private CommandRegistry commandRegistry;


  @Override
  protected void doHandleResult(ParameterMissingResolutionException missing) {
      //retrieve some information to provide the right information
      String type_parameter = missing.getParameterDescription().formal();
      List<String> name_possible = missing.getParameterDescription().keys();
      String help_parameter = missing.getParameterDescription().help();
      ShellMethod shell_method = (ShellMethod) missing.getParameterDescription().parameter()
          .getAnnotatedElement().getAnnotation(ShellMethod.class);

      String[] names_method = shell_method.key();
      String name_default_method = names_method[0];

      //Here, I call the "help" command to provide all the information
      Method help_method = commandRegistry.listCommands().get("help").getMethod();
      Object help_instance = commandRegistry.listCommands().get("help").getBean();

      Object help_message = ReflectionUtils.invokeMethod(
          help_method,
          help_instance,
          name_default_method
      );
      // Here is the format to show the information 
      terminal.writer().println(
          new AttributedString(
              String.format(
                  "The command %s required the attribute \"%s\" of type \"%s\" that uses for \"%s\"",
                  Arrays.toString(names_method),
                  name_possible,
                  type_parameter,
                  help_parameter
              ),
              AttributedStyle.DEFAULT.foreground(AttributedStyle.RED)
          )
              .toAnsi()
      );

    terminal.writer().println(
        new AttributedString(
            String.format(
                "For more details, take a look at the description below."
            ),
            AttributedStyle.DEFAULT.foreground(AttributedStyle.RED)
        )
            .toAnsi()
    );
     // Help message printed in green to show that it is not part of the error, but it is information
      terminal.writer().println(
          new AttributedString(
              help_message.toString(),
              AttributedStyle.DEFAULT.foreground(AttributedStyle.GREEN)
          )
              .toAnsi()
      );
  }

}

2. In your configuration "class" I add the following bean:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfiguration {
... 

  @Bean
  public ParameterMissingResultHandler parameterMissingResultHandler() {
    return new ParameterMissingResultHandler();
  }

...

I hope you found it useful :D

The idea comes from the code of ParameterValidationExceptionResultHandler and ResultHandlerConfig