Is there a way to implement multiple level verbs?

Issue by akfish Thursday Oct 31, 2013 at 19:48 GMT _Originally opened as https://github.com/gsscoder/commandline/issues/107_

---

I am trying to make an app with multiple level of verbs, something like:

app repo list
app repo add
app account list

What I tried is:

    class Options
    {
        #region Global Options
        //...
        #endregion

        #region Help
        //..
        #endregion

        #region Verbs
        [VerbOption("account", HelpText = "Manage mail accounts")]
        public AccountOptions AccountVerb { get; set; }

        [VerbOption("repo", HelpText = "Manage repositories")]
        public RepoOptions RepoVerb { get; set; }
        #endregion
    }

In each verb, nested a sub verb:

    class AccountOptions : IOptions
    {
        [VerbOption("add", HelpText = "Add an account")]
        public AddOption AddVerb { get; set; }

        //And so on....

        public class AddOption : IOptions
        {
        }
        //And so on....

    }

main:

    class Program
    {
        static void Main(string[] args)
        {
            string theVerb = null;
            IOptions theOptions = null;

            var options = new Options();
            if (CommandLine.Parser.Default.ParseArguments(args, options, (verb, subOptions) =>
            {
                theVerb = verb;
                if (verb != null)
                    theOptions = subOptions as IOptions;
            }))
            {
                theOptions.Execute(options);
            }
            else
            {
                Console.Error.WriteLine("Command line parsing error.");
            }
        }
    }

I was able to get first level of verbs to working (e.g. app repo, app account, as the documents said. But the second level ones (app account list, app account add) didn’t.

So is there a way to do this? Thanks.

[laterwet]

A small trick I found that works quite well. When I find a match with an existing sub-parser (verb), I skip the 1st argument, and forward it to another Parser. This could be done recursively, and probably in a better way than reflection.

    interface ISubParser
    {
        int RunAndReturnExitCode(string[] args);
    }

    [Verb("repo", HelpText = "Manage repositories.")]
    public class RepoVerb : ISubParser
    {
        int ISubParser.RunAndReturnExitCode(string[] args)
        {
            return Parser.Default.ParseArguments<AddOptions, RemoveOptions>(args)
                .MapResult(
                  (AddOptions opts) => AddRepo.RunAndReturnExitCode(opts),
                  (RemoveOptions opts) => RemoveRepo.RunAndReturnExitCode(opts),
                  errs => 1);
        }
    }

    class Program
    {
        private static Type GetSubParser(string verb)
        {
            return Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(x =>
                typeof(ISubParser).IsAssignableFrom(x)
                && x.GetCustomAttribute<VerbAttribute>()?.Name == verb);
        }

        static int Main(string[] args)
        {
            if (args.Length > 0)
            {
                Type type = GetSubParser(args[0]);
                if (type != null)
                {
                    // Command with sub-verbs
                    return (Activator.CreateInstance(type) as ISubParser).RunAndReturnExitCode(args.Skip(1).ToArray());
                }
            }

            return Parser.Default.ParseArguments<RepoVerb, AccountVerb>(args)
                .MapResult(
                  (RepoVerb opts) => 1,
                  (AccountVerb opts) => 1,
                  errs => 1);
        }
    }

[ericnewton76]

Comment by akfish Tuesday Dec 02, 2014 at 07:01 GMT

---

@Nate-Wilkins I was able to implement this feature in my project without actually modifying this project. Here is my implementation: https://github.com/akfish/git-mail/tree/develop/git-mail

You should know that the project linked above was never finished, since later I moved on to node.js for cross-platform purpose and I haven’t been working on .Net platform for almost a year. But the CLI part was completed and would hopefully give you some hints.