How to dynamically assigning global optional options to command required options?

[ptr727]

I released my project using global required options used by all commands, but I now introduced commands that do not use the options, and I moved the required options to only the commands that need them.

This causes a problem for backwards compatibility, forcing users to change their commandlines from e.g.
From: foo --optionone one mycommand --anotheroption two
To: foo mycommand --optionone one --anotheroption two

I would like to keep the global options but marked them as not required, and then add the same options to individual commands but mark them as required.
But, if the option had been specified globally, I want to dynamically assign the command option from the global option, and emit a warning to the user to change the commandline, and then much later deprecate the old format.

How could I do that?

P.s. currently using Beta 4, changes in the develop branch, see here.

[jonsequitur]

You can possibly do this by using the Option<T> constructor that takes a ParseArgument<T> and walking up from the ArgumentResult to find the parent command. I tried it and the code wasn't pretty, though.

#2031 was opened to make this a little easier on the latest (i.e. not on nuget.org) version but we could likely come up with an easier-to-use API.

[ptr727]

Ok, thx, I looked the diff, not quite sure how to use it?

[jonsequitur]

Here's an example (using the latest code, not necessarily the latest beta4 package on nuget.org) that I think does roughly what you're looking for:

var commandOne = new Command("one");

var optionOne = new Option<string>(
    "--optionone",
    argResult =>
    {
        var value = argResult.Tokens.FirstOrDefault()?.Value;

        var command = argResult.FindResultFor(commandOne);

        if (command is not null && value is null)
        {
            argResult.ErrorMessage = "--optionone is required when using command one";
        }

        return value;
    }, isDefault: true);

commandOne.Add(optionOne);

commandOne.SetHandler(_ => { }); // set empty handler to prevent errors re: non-invocable commands
var rootCommand = new RootCommand("root")
{
    optionOne,
    commandOne
};
rootCommand.SetHandler(_ => { }); // set empty handler to prevent errors re: non-invocable commands

var parseResult = rootCommand.Parse("");
parseResult.Errors.Should().BeEmpty();

parseResult = rootCommand.Parse("--optionone hello");
parseResult.Errors.Should().BeEmpty();

parseResult = rootCommand.Parse("one --optionone hello");
parseResult.Errors.Should().BeEmpty();

parseResult = rootCommand.Parse("one");
parseResult.Errors.Should().ContainSingle(e => e.Message == "--optionone is required when using command one");

[ptr727]

Thank you, I will give it a try (currently away from desk, will report back in a week or two).

[ptr727]

Given the complexity of having to refactor to get access between options and global options, I decided to leave it as a breaking change.