Command with parameter

[XVincentX]

Hello,
I was wondering if fclp has got a command concept with per-command parameters.
Something like this:

SetupCommand("create")
.WithParam("initialUrl")
.Required()

SetupCommand("restore")
.WithParam("fromFile")
.Required()

And then use it in this way

myApp.exe create --initialUrl http://www.google.it
myApp.exe restore --fromFile C:\data.json

[siywilliams]

No support at the moment for commands, although I do like them and would love to see future support in fclp.

It would need to support multiple parameters for each command, each with callback, required and description methods etc. There is also the generic fclp that constructs an argument object, this would need to support it too.

[XVincentX]

Indeed. Thank you for your attention! Looking forward to get its support.

[siywilliams]

I'm just exploring how git style commands could work within the existing FCLP framework, if anyone has any feedback that would be great. I'm trying to extend its functionality rather than replace the two current techniques of setting up expected options.

I'm working on a simple example of an app that tracks files, which can be added and removed.

myapp add -f "c:\file1.txt" "c:\file2.txt" --verbose --ignore-errors
myapp remove -f "c:\file1.txt" "c:\file2.txt" --verbose

We have two commands here, Add and Remove, both can have different options and rules.

// Contains all arguments for the add command
class AddArgs {
 bool Verbose;
 bool IgnoreErrors;
 IEnumerable<string> Files;
}

// Contains all arguments for the remove command
class RemoveArgs {
 bool Verbose;
 IEnumerable<string> Files;
}

// entry point into console app
static void Main(string[] args) {
 var fclp = new FluentCommandLineParser();

// use new SetupCommand method to initialise a command
 var addCmd = fclp.SetupCommand<AddArgs>("add")
                  .Callback(args => Add(args)); // executed when the add command is used

// the standard fclp framework, except against the created command rather than the fclp itself
 addCmd.Setup(args => args.Verbose)
       .As('v', "verbose")
       .SetDefault(false)
       .WithDescription("Be verbose");

 addCmd.Setup(args => args.IgnoreErrors)
       .As("ignore-errors")
       .SetDefault(false)
       .WithDescription("If some files could not be added, do not abort");

 addCmd.Setup(args => args.Files)
       .As('f', "files")
       .Description("Files to be tracked");

// add the remove command
 var removeCmd = fclp.SetupCommand<RemoveArgs>("remove")
                     .Callback(args => Remove(args)); // executed when the remove command is used

 removeCmd.Setup(args => args.Verbose)
          .As('v', "verbose")
          .SetDefault(false)
          .WithDescription("Be verbose");

 removeCmd.Setup(args => args.Files)
          .As('f', "files")
          .WithDescription("Files to be untracked");

 fclp.Parse(args);
}

void Add(AddArgs args){
  // add was executed
}

void Remove(RemoveArgs args){
  // remove was executed
}

Perhaps I should have created a gist!

[XVincentX]

Hey, thank you very much for the response, I am definitely glad that you're working on the issue.
I am afraid that actually I've lost a bit of context about the code here, and I ended up switching to PowerArgs. Anyhow I'll take a bit of time to re-set up the context and let you know my opinions on that.

Thank you very much!