is it possible to specify global arguments for parser and sub-parsers.

[steven-varga]

Great work with good syntax!... and now I am wondering if there is a way specify global argument; a single expression being visible in all sub-parsers?

[hellflame]

Can you give some example on that? I'm not quite clear what's it like.

[steven-varga]

I am interested in having --verbose argument be present across all sub-commands.

usage: prog <cmd> [--help] [--completion] [--verbose LEVEL] 

some software with sub commands

commands:
  sub01     description 01
  sub02     description 02
  sub03     description 03

options:
  --help, -h    show this help message
  --completion  show command completion script
  --verbose LEVEL

Using a global variable, and actions set for sub-commands gives me the desired behaviour; is there a more idiomatic way to get the same effect?

[hellflame]

Now I get the picture.
is it like:

parser := argparse.NewParser("", "", nil)
verbose := parser.String("v", "verbose", &argparse.Option{Inherit: true})  // use "inherit" for example, the name is not decided yet

sub := parser.AddCommand("sub", "", nil)
o := sub.Flag("o", "", nil)

if e := parser.Parse(nil); e != nil {
    return
}

print(*verbose, *o)

Then users can use prog --verbose or prog sub --verbose, and program get *verbose to be true.
Is that right?

[steven-varga]

The proposed idea is so good I had to go and check if already existed (and I missed this somehow). I like this very much! Do you think it would be pushing my luck to have a feature to block this proposed feature somehow? Now I admit this was not my most intelligent expression of the day, but it is still early morning in Toronto Canada, and I could beat this.

What I meant to say: picture a tree, where the arg propagates along the branches when Inherit: true is set, except on a sub-tree where you block it on a specific branch: Inherit: false.
The use case is to connect to a --url redis:... with default argument, except one or two leaf nodes where you don't.

[hellflame]

I came up with a few words to best describe your idea, and I picked Inherit thinking it would be more generic (name is alway very important).

When I see this line

The use case is to connect to a --url redis:... with default argument, except one or two leaf nodes where you don't.

I came up with other Idea to complete your case, I might use environment variables to do so, like:

# use env `url`
url=redis://user:password@127.0.0.1:6379 prog xxx xxx

then you can get this url by os.Getenv("url") at any where you want.

---

But, I think Inherit the idea can make the program easier to use, at least users will know there is a url, while url in env is not quite clear.
About which sub-tree not to Inherit, Actually I got some other thoughts. As such inherit action should not exist too often or too complex (dozens of inherits with here and there inherit or not confusion), I thought:

1. AddCommand only inherit arguments with Inherit: true before it, or it won't

parser := argparse.NewParser("", "", nil)
verbose := parser.String("v", "", &argparse.Option{Inherit: true})

sub := parser.AddCommand("sub", "", nil) // inherit 'verbose' from root parser
o := sub.Flag("o", "", nil)

name := parser.String("n", "", &argparse.Option{Inherit: true}) // this will not be inherit by 'sub'

sub2 := parser.AddCommand("sub2", "", nil) // inhert 'verbose' and 'name' from root parser
age := sub2.Int("a", "age", nil)

if e := parser.Parse(nil); e != nil {
    return
}
print(*verbose, *o, *name, *age)

2. As there's Inherit, sub-command can overwrite inherited arguments

parser := argparse.NewParser("", "", nil)
verbose := parser.String("v", "", &argparse.Option{Inherit: true})

sub := parser.AddCommand("sub", "", nil) // inherit 'verbose' from root parser
o := sub.Flag("o", "", nil)

name := parser.String("n", "", &argparse.Option{Inherit: true}) // this will not be inherit by 'sub'

sub2 := parser.AddCommand("sub2", "", nil) // inhert 'verbose' and 'name' from root parser
age := sub2.Int("a", "age", nil)
version := sub2.Flag("v", "", nil) // overwrite 'verbose' for version

if e := parser.Parse(nil); e != nil {
    return
}
print(*verbose, *o, *name, *age, *version)

Any thoughts about those above?

[steven-varga]

I am for simplicity! The environment variable indeed is a working solution, except that is not a self documented flexible argument.

I picked Inherit thinking it would be more generic (name is always very important) I can't agree more. I like the word Inherit but the devil inside tells me the relationship is the opposite: leave-to-descendent, an awkward expression indeed, if only leave-to-descendent wouldn't beat my previous bad idea!

[hellflame]

Alright, I guess I'll try to implement this feature with an argument option Inheritable (meaning sub-commands may inherit this argument, with the features presented in my previous comment, leave-to-descendent is a little bit too long for poor memories).
If everything (mainly the time, or I changed my mind) is ok, it will be finished before this weekend.

Also, after second thought about your quest, I've got some suggests.

If it's related to some urgent task, environment variable should be just ok.
If it's not urgent and you won't mind some more code, these code might do the same trick:

parser := argparse.NewParser("", "", nil)
sub := parser.AddCommand("sub", "", nil)
sub2 := parser.AddCommand("sub2", "", nil)

url := ""
for _, p := range []*argparse.Parser{parser, sub, sub2} {
    p.String("", "url", &argparse.Option{Action: func(args []string) error {
        url = args[0]
        return nil
    }})
}

if e := parser.Parse(nil); e != nil {
    return
}
print(url)

[steven-varga]

Thanks! I like Inheritable... will check in later for the update (I have a temporary fix)

[hellflame]

Inheritable in now usable. just update version to latest v1.8.0

It's documented here https://github.com/hellflame/argparse#16-inheriable-argument---180-