How to properly use execute with programmatic API?

[Kadeluxe]

Hi!
I'm currently looking for Java command parsing libraries and picocli looks amazing at the first glance, however I'm stuck trying to get a simple example working.

So I want to use it without any annotations. I quickly wrote this to test how it works:

    CommandLine subcommand;

    {
      var spec = CommandSpec.wrapWithoutInspection(new Runnable() {
          @Override
          public void run() {
            System.out.println("subcommand::run");
          }
        })
        .name("subcommand");
      spec.addOption(OptionSpec.builder("-f").paramLabel("flag1").type(String.class).build());
      spec.addPositional(PositionalParamSpec.builder().index("0").paramLabel("pos1").type(String.class).required(true).build());
      spec.addPositional(PositionalParamSpec.builder().index("1").paramLabel("pos2").type(Boolean.class).required(true).build());

      subcommand = new CommandLine(spec);
    }

    {
      var spec = CommandSpec.wrapWithoutInspection(new Runnable() {
        @Override
        public void run() {
          System.out.println("program::run");
        }
      });

      spec
        .name("program")
        .addPositional(PositionalParamSpec.builder().index("0").paramLabel("pos1").type(Integer.class).build());

      var commandLine = new CommandLine(spec);
      commandLine.setExecutionStrategy(new CommandLine.RunAll());

      commandLine.addSubcommand("subcommand", subcommand);

      commandLine.execute("subcommand -f flagValue p1 true".split("\\s+"));
    }

And apparently it works as intended, I can execute both subcommand and top-level command with positional arg.
Now the question is, how do I access parse results inside my Runnables?
Like, how do I get flag1 value inside that Runnable of subcommand?

Is it even the proper way to do it?
Basically I thought that I can build a command graph using CommandSpecs, then feed the top-level command some string input and picocli would automatically parse and dispatch commands, executing whatever runnables match. Is it correct?

[remkop]

When using the annotations API, your @Command-annotated class that implements Runnable can have a field to inject the CommandSpec:

@Command // example that uses the annotations API
class MyCommand implements Runnable {
    @Spec CommandSpec spec; // injected by picocli during initialization
    @Option(names = "-x") String x; // injected by picocli during parsing (before execution)

    public void run() {
        // do something with x
    }
}

In the programmatic API, one idea is to inject the spec yourself:

class MyRunnable implements Runnable { // define the business logic
    CommandSpec spec; // to be manually injected, see below
    public void run() {
        ParseResult pr = spec.commandLine().getParseResult(); // get parse result

        // see https://picocli.info/picocli-programmatic-api.html#_parse_result
        if (pr.hasMatchedOption("-x")) {
            // do something because x was specified
        }
    }
}

MyRunnable myRunnable = new MyRunnable();
CommandSpec spec = CommandSpec.wrapWithoutInspection(myRunnable);
myRunnable.spec = spec; // inject manually
new CommandLine(spec).execute(args);

An alternative may be to use CommandLine.parseArgs instead of CommandLine.execute, and have the business logic completely separate. Most of the examples in the programmatic API docs show that usage. (That said, the execute API does provide a lot of functionality that you would need to manually implement if you use parseArgs.)

[Kadeluxe]

Thank you, this is helpful.
It seems that if I use CommandLine.parseArgs then I would also need to deal with execution of subcommands on my own, am I right?

[remkop]

Yes that is correct. The execute API does quite a lot of work.

[Kadeluxe]

Thanks, for some reason I thought that CommandSpec during execution is not the same as initial CommandSpec. It's a lot clearer now.