x
/
argh
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Collapse together Command and Flag into CommandFlag

Browse Source
main
Dan Buch 1 year ago
parent b97681c710
commit 871b7aa4f0
Signed by: meatballhat
GPG Key ID: A12F782281063434
6 changed files with 236 additions and 263 deletions
Show Stats Download Patch File Download Diff File

16
argh_test.go
Unescape View File

@ -80,13 +80,13 @@ func BenchmarkArgh(b *testing.B) {
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"ok": { "ok": {
On: func(fl argh.Flag) { On: func(fl argh.CommandFlag) {
okFlag = ptrTo(true) okFlag = ptrTo(true)
}, },
}, },
"dur": { "dur": {
NValue: 1, NValue: 1,
On: func(fl argh.Flag) { On: func(fl argh.CommandFlag) {
if v, ok := fl.Values["0"]; ok { if v, ok := fl.Values["0"]; ok {
if pt, err := time.ParseDuration(v); err != nil { if pt, err := time.ParseDuration(v); err != nil {
durFlag = ptrTo(pt) durFlag = ptrTo(pt)
@ -96,7 +96,7 @@ func BenchmarkArgh(b *testing.B) {
}, },
"f64": { "f64": {
NValue: 1, NValue: 1,
On: func(fl argh.Flag) { On: func(fl argh.CommandFlag) {
if v, ok := fl.Values["0"]; ok { if v, ok := fl.Values["0"]; ok {
if f, err := strconv.ParseFloat(v, 64); err == nil { if f, err := strconv.ParseFloat(v, 64); err == nil {
f64Flag = ptrTo(f) f64Flag = ptrTo(f)
@ -106,7 +106,7 @@ func BenchmarkArgh(b *testing.B) {
}, },
"i": { "i": {
NValue: 1, NValue: 1,
On: func(fl argh.Flag) { On: func(fl argh.CommandFlag) {
if v, ok := fl.Values["0"]; ok { if v, ok := fl.Values["0"]; ok {
if i, err := strconv.ParseInt(v, 10, 64); err == nil { if i, err := strconv.ParseInt(v, 10, 64); err == nil {
iFlag = ptrTo(int(i)) iFlag = ptrTo(int(i))
@ -116,7 +116,7 @@ func BenchmarkArgh(b *testing.B) {
}, },
"i64": { "i64": {
NValue: 1, NValue: 1,
On: func(fl argh.Flag) { On: func(fl argh.CommandFlag) {
if v, ok := fl.Values["0"]; ok { if v, ok := fl.Values["0"]; ok {
if i, err := strconv.ParseInt(v, 10, 64); err == nil { if i, err := strconv.ParseInt(v, 10, 64); err == nil {
i64Flag = ptrTo(i) i64Flag = ptrTo(i)
@ -126,7 +126,7 @@ func BenchmarkArgh(b *testing.B) {
}, },
"s": { "s": {
NValue: 1, NValue: 1,
On: func(fl argh.Flag) { On: func(fl argh.CommandFlag) {
if v, ok := fl.Values["0"]; ok { if v, ok := fl.Values["0"]; ok {
sFlag = ptrTo(v) sFlag = ptrTo(v)
} }
@ -134,7 +134,7 @@ func BenchmarkArgh(b *testing.B) {
}, },
"u": { "u": {
NValue: 1, NValue: 1,
On: func(fl argh.Flag) { On: func(fl argh.CommandFlag) {
if v, ok := fl.Values["0"]; ok { if v, ok := fl.Values["0"]; ok {
if u, err := strconv.ParseUint(v, 10, 64); err == nil { if u, err := strconv.ParseUint(v, 10, 64); err == nil {
uFlag = ptrTo(uint(u)) uFlag = ptrTo(uint(u))
@ -144,7 +144,7 @@ func BenchmarkArgh(b *testing.B) {
}, },
"u64": { "u64": {
NValue: 1, NValue: 1,
On: func(fl argh.Flag) { On: func(fl argh.CommandFlag) {
if v, ok := fl.Values["0"]; ok { if v, ok := fl.Values["0"]; ok {
if u, err := strconv.ParseUint(v, 10, 64); err == nil { if u, err := strconv.ParseUint(v, 10, 64); err == nil {
u64Flag = ptrTo(u) u64Flag = ptrTo(u)

23
ast.go
Unescape View File

@ -25,7 +25,7 @@ func ToAST(parseTree []Node) []Node {
continue continue
} }
if v, ok := node.(*Command); ok { if v, ok := node.(*CommandFlag); ok {
astNodes := ToAST(v.Nodes) astNodes := ToAST(v.Nodes)
if len(astNodes) == 0 { if len(astNodes) == 0 {
@ -34,7 +34,7 @@ func ToAST(parseTree []Node) []Node {
ret = append( ret = append(
ret, ret,
&Command{ &CommandFlag{
Name: v.Name, Name: v.Name,
Values: v.Values, Values: v.Values,
Nodes: astNodes, Nodes: astNodes,
@ -43,25 +43,6 @@ func ToAST(parseTree []Node) []Node {
continue continue
} }
if v, ok := node.(*Flag); ok {
astNodes := ToAST(v.Nodes)
if len(astNodes) == 0 {
astNodes = nil
}
ret = append(
ret,
&Flag{
Name: v.Name,
Values: v.Values,
Nodes: astNodes,
},
)
continue
}
ret = append(ret, node) ret = append(ret, node)
} }

10
node.go
Unescape View File

@ -25,13 +25,9 @@ type BadArg struct {
To Pos To Pos
} }
type Command struct { // CommandFlag is a Node with a name, a slice of child Nodes, and
Name string // potentially a map of named values derived from the child Nodes
Values map[string]string type CommandFlag struct {
Nodes []Node
}
type Flag struct {
Name string Name string
Values map[string]string Values map[string]string
Nodes []Node Nodes []Node

14
parser.go
Unescape View File

@ -92,7 +92,7 @@ func (p *parser) next() {
func (p *parser) parseCommand(cCfg *CommandConfig) Node { func (p *parser) parseCommand(cCfg *CommandConfig) Node {
tracef("parseCommand(%+#v)", cCfg) tracef("parseCommand(%+#v)", cCfg)
node := &Command{ node := &CommandFlag{
Name: p.lit, Name: p.lit,
} }
values := map[string]string{} values := map[string]string{}
@ -217,7 +217,7 @@ func (p *parser) parseFlag(flags *Flags) Node {
} }
func (p *parser) parseShortFlag(flags *Flags) Node { func (p *parser) parseShortFlag(flags *Flags) Node {
node := &Flag{Name: string(p.lit[1])} node := &CommandFlag{Name: string(p.lit[1])}
flCfg, ok := flags.Get(node.Name) flCfg, ok := flags.Get(node.Name)
if !ok { if !ok {
@ -230,7 +230,7 @@ func (p *parser) parseShortFlag(flags *Flags) Node {
} }
func (p *parser) parseLongFlag(flags *Flags) Node { func (p *parser) parseLongFlag(flags *Flags) Node {
node := &Flag{Name: string(p.lit[2:])} node := &CommandFlag{Name: string(p.lit[2:])}
flCfg, ok := flags.Get(node.Name) flCfg, ok := flags.Get(node.Name)
if !ok { if !ok {
@ -243,13 +243,13 @@ func (p *parser) parseLongFlag(flags *Flags) Node {
} }
func (p *parser) parseCompoundShortFlag(flags *Flags) Node { func (p *parser) parseCompoundShortFlag(flags *Flags) Node {
unparsedFlags := []*Flag{} unparsedFlags := []*CommandFlag{}
unparsedFlagConfigs := []FlagConfig{} unparsedFlagConfigs := []FlagConfig{}
withoutFlagPrefix := p.lit[1:] withoutFlagPrefix := p.lit[1:]
for _, r := range withoutFlagPrefix { for _, r := range withoutFlagPrefix {
node := &Flag{Name: string(r)} node := &CommandFlag{Name: string(r)}
flCfg, ok := flags.Get(node.Name) flCfg, ok := flags.Get(node.Name)
if !ok { if !ok {
@ -295,11 +295,11 @@ func (p *parser) parseCompoundShortFlag(flags *Flags) Node {
return &CompoundShortFlag{Nodes: flagNodes} return &CompoundShortFlag{Nodes: flagNodes}
} }
func (p *parser) parseConfiguredFlag(node *Flag, flCfg FlagConfig, nValueOverride *NValue) Node { func (p *parser) parseConfiguredFlag(node *CommandFlag, flCfg FlagConfig, nValueOverride *NValue) Node {
values := map[string]string{} values := map[string]string{}
nodes := []Node{} nodes := []Node{}
atExit := func() *Flag { atExit := func() *CommandFlag {
if len(nodes) > 0 { if len(nodes) > 0 {
node.Nodes = nodes node.Nodes = nodes
} }

4
parser_config.go
Unescape View File

@ -72,7 +72,7 @@ type CommandConfig struct {
Flags *Flags Flags *Flags
Commands *Commands Commands *Commands
On func(Command) On func(CommandFlag)
} }
func (cCfg *CommandConfig) init() { func (cCfg *CommandConfig) init() {
@ -114,7 +114,7 @@ type FlagConfig struct {
Persist bool Persist bool
ValueNames []string ValueNames []string
On func(Flag) On func(CommandFlag)
} }
type Flags struct { type Flags struct {

432
parser_test.go
Unescape View File

@ -9,12 +9,8 @@ import (
) )
func TestParser(t *testing.T) { func TestParser(t *testing.T) {
traceOnFlag := func(fl argh.Flag) { traceOnCommandFlag := func(cmd argh.CommandFlag) {
t.Logf("Flag.On: %+#[1]v", fl) t.Logf("CommandFlag.On: %+#[1]v", cmd)
}
traceOnCommand := func(cmd argh.Command) {
t.Logf("Command.On: %+#[1]v", cmd)
} }
for _, tc := range []struct { for _, tc := range []struct {
@ -35,10 +31,10 @@ func TestParser(t *testing.T) {
Prog: &argh.CommandConfig{ Prog: &argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"e": {On: traceOnFlag}, "e": {On: traceOnCommandFlag},
"a": {On: traceOnFlag}, "a": {On: traceOnCommandFlag},
"t": {On: traceOnFlag}, "t": {On: traceOnCommandFlag},
"wat": {On: traceOnFlag}, "wat": {On: traceOnCommandFlag},
}, },
}, },
Commands: &argh.Commands{ Commands: &argh.Commands{
@ -46,29 +42,29 @@ func TestParser(t *testing.T) {
"hello": argh.CommandConfig{ "hello": argh.CommandConfig{
NValue: 1, NValue: 1,
ValueNames: []string{"name"}, ValueNames: []string{"name"},
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pies", Name: "pies",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.CompoundShortFlag{ &argh.CompoundShortFlag{
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "e"}, &argh.CommandFlag{Name: "e"},
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "t"}, &argh.CommandFlag{Name: "t"},
}, },
}, },
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "wat"}, &argh.CommandFlag{Name: "wat"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Command{ &argh.CommandFlag{
Name: "hello", Name: "hello",
Values: map[string]string{ Values: map[string]string{
"name": "mario", "name": "mario",
@ -82,14 +78,14 @@ func TestParser(t *testing.T) {
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pies", Name: "pies",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "e"}, &argh.CommandFlag{Name: "e"},
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "t"}, &argh.CommandFlag{Name: "t"},
&argh.Flag{Name: "wat"}, &argh.CommandFlag{Name: "wat"},
&argh.Command{ &argh.CommandFlag{
Name: "hello", Name: "hello",
Values: map[string]string{ Values: map[string]string{
"name": "mario", "name": "mario",
@ -112,13 +108,13 @@ func TestParser(t *testing.T) {
cmdCfg := &argh.CommandConfig{ cmdCfg := &argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"e": {Persist: true, On: traceOnFlag}, "e": {Persist: true, On: traceOnCommandFlag},
"a": {Persist: true, On: traceOnFlag}, "a": {Persist: true, On: traceOnCommandFlag},
"t": {Persist: true, On: traceOnFlag}, "t": {Persist: true, On: traceOnCommandFlag},
"wat": {On: traceOnFlag}, "wat": {On: traceOnCommandFlag},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
} }
cmdCfg.Commands = &argh.Commands{ cmdCfg.Commands = &argh.Commands{
@ -130,7 +126,7 @@ func TestParser(t *testing.T) {
Parent: cmdCfg.Flags, Parent: cmdCfg.Flags,
Map: map[string]argh.FlagConfig{}, Map: map[string]argh.FlagConfig{},
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
} }
@ -139,13 +135,13 @@ func TestParser(t *testing.T) {
}(), }(),
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pies", Name: "pies",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "wat"}, &argh.CommandFlag{Name: "wat"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Command{ &argh.CommandFlag{
Name: "hello", Name: "hello",
Values: map[string]string{ Values: map[string]string{
"name": "mario", "name": "mario",
@ -156,9 +152,9 @@ func TestParser(t *testing.T) {
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.CompoundShortFlag{ &argh.CompoundShortFlag{
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "e"}, &argh.CommandFlag{Name: "e"},
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "t"}, &argh.CommandFlag{Name: "t"},
}, },
}, },
}, },
@ -167,20 +163,20 @@ func TestParser(t *testing.T) {
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pies", Name: "pies",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "wat"}, &argh.CommandFlag{Name: "wat"},
&argh.Command{ &argh.CommandFlag{
Name: "hello", Name: "hello",
Values: map[string]string{ Values: map[string]string{
"name": "mario", "name": "mario",
}, },
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Ident{Literal: "mario"}, &argh.Ident{Literal: "mario"},
&argh.Flag{Name: "e"}, &argh.CommandFlag{Name: "e"},
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "t"}, &argh.CommandFlag{Name: "t"},
}, },
}, },
}, },
@ -191,12 +187,12 @@ func TestParser(t *testing.T) {
name: "bare", name: "bare",
args: []string{"pizzas"}, args: []string{"pizzas"},
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
}, },
}, },
@ -205,10 +201,10 @@ func TestParser(t *testing.T) {
name: "one positional arg", name: "one positional arg",
args: []string{"pizzas", "excel"}, args: []string{"pizzas", "excel"},
cfg: &argh.ParserConfig{ cfg: &argh.ParserConfig{
Prog: &argh.CommandConfig{NValue: 1, On: traceOnCommand}, Prog: &argh.CommandConfig{NValue: 1, On: traceOnCommandFlag},
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Values: map[string]string{"0": "excel"}, Values: map[string]string{"0": "excel"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -218,7 +214,7 @@ func TestParser(t *testing.T) {
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Values: map[string]string{"0": "excel"}, Values: map[string]string{"0": "excel"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -234,11 +230,11 @@ func TestParser(t *testing.T) {
Prog: &argh.CommandConfig{ Prog: &argh.CommandConfig{
NValue: argh.OneOrMoreValue, NValue: argh.OneOrMoreValue,
ValueNames: []string{"word"}, ValueNames: []string{"word"},
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Values: map[string]string{ Values: map[string]string{
"word": "excel", "word": "excel",
@ -259,7 +255,7 @@ func TestParser(t *testing.T) {
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Values: map[string]string{ Values: map[string]string{
"word": "excel", "word": "excel",
@ -283,34 +279,34 @@ func TestParser(t *testing.T) {
Prog: &argh.CommandConfig{ Prog: &argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"tasty": {On: traceOnFlag}, "tasty": {On: traceOnCommandFlag},
"fresh": {On: traceOnFlag}, "fresh": {On: traceOnCommandFlag},
"super-hot-right-now": {On: traceOnFlag}, "super-hot-right-now": {On: traceOnCommandFlag},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "tasty"}, &argh.CommandFlag{Name: "tasty"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "fresh"}, &argh.CommandFlag{Name: "fresh"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "super-hot-right-now"}, &argh.CommandFlag{Name: "super-hot-right-now"},
}, },
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "tasty"}, &argh.CommandFlag{Name: "tasty"},
&argh.Flag{Name: "fresh"}, &argh.CommandFlag{Name: "fresh"},
&argh.Flag{Name: "super-hot-right-now"}, &argh.CommandFlag{Name: "super-hot-right-now"},
}, },
}, },
}, },
@ -330,24 +326,24 @@ func TestParser(t *testing.T) {
Commands: &argh.Commands{Map: map[string]argh.CommandConfig{}}, Commands: &argh.Commands{Map: map[string]argh.CommandConfig{}},
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"tasty": {On: traceOnFlag}, "tasty": {On: traceOnCommandFlag},
"fresh": argh.FlagConfig{NValue: 1, On: traceOnFlag}, "fresh": argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
"super-hot-right-now": {On: traceOnFlag}, "super-hot-right-now": {On: traceOnCommandFlag},
"box": argh.FlagConfig{NValue: argh.OneOrMoreValue, On: traceOnFlag}, "box": argh.FlagConfig{NValue: argh.OneOrMoreValue, On: traceOnCommandFlag},
"please": {On: traceOnFlag}, "please": {On: traceOnCommandFlag},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "tasty"}, &argh.CommandFlag{Name: "tasty"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{ &argh.CommandFlag{
Name: "fresh", Name: "fresh",
Values: map[string]string{"0": "soon"}, Values: map[string]string{"0": "soon"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -356,9 +352,9 @@ func TestParser(t *testing.T) {
}, },
}, },
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "super-hot-right-now"}, &argh.CommandFlag{Name: "super-hot-right-now"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{ &argh.CommandFlag{
Name: "box", Name: "box",
Values: map[string]string{"0": "square", "1": "shaped", "2": "hot"}, Values: map[string]string{"0": "square", "1": "shaped", "2": "hot"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -371,24 +367,24 @@ func TestParser(t *testing.T) {
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
}, },
}, },
&argh.Flag{Name: "please"}, &argh.CommandFlag{Name: "please"},
}, },
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "tasty"}, &argh.CommandFlag{Name: "tasty"},
&argh.Flag{ &argh.CommandFlag{
Name: "fresh", Name: "fresh",
Values: map[string]string{"0": "soon"}, Values: map[string]string{"0": "soon"},
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Ident{Literal: "soon"}, &argh.Ident{Literal: "soon"},
}, },
}, },
&argh.Flag{Name: "super-hot-right-now"}, &argh.CommandFlag{Name: "super-hot-right-now"},
&argh.Flag{ &argh.CommandFlag{
Name: "box", Name: "box",
Values: map[string]string{"0": "square", "1": "shaped", "2": "hot"}, Values: map[string]string{"0": "square", "1": "shaped", "2": "hot"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -397,7 +393,7 @@ func TestParser(t *testing.T) {
&argh.Ident{Literal: "hot"}, &argh.Ident{Literal: "hot"},
}, },
}, },
&argh.Flag{Name: "please"}, &argh.CommandFlag{Name: "please"},
}, },
}, },
}, },
@ -409,34 +405,34 @@ func TestParser(t *testing.T) {
Prog: &argh.CommandConfig{ Prog: &argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"t": {On: traceOnFlag}, "t": {On: traceOnCommandFlag},
"f": {On: traceOnFlag}, "f": {On: traceOnCommandFlag},
"s": {On: traceOnFlag}, "s": {On: traceOnCommandFlag},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "t"}, &argh.CommandFlag{Name: "t"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "f"}, &argh.CommandFlag{Name: "f"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "s"}, &argh.CommandFlag{Name: "s"},
}, },
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "t"}, &argh.CommandFlag{Name: "t"},
&argh.Flag{Name: "f"}, &argh.CommandFlag{Name: "f"},
&argh.Flag{Name: "s"}, &argh.CommandFlag{Name: "s"},
}, },
}, },
}, },
@ -448,51 +444,51 @@ func TestParser(t *testing.T) {
Prog: &argh.CommandConfig{ Prog: &argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"a": {On: traceOnFlag}, "a": {On: traceOnCommandFlag},
"b": {On: traceOnFlag}, "b": {On: traceOnCommandFlag},
"c": {On: traceOnFlag}, "c": {On: traceOnCommandFlag},
"l": {On: traceOnFlag}, "l": {On: traceOnCommandFlag},
"o": {On: traceOnFlag}, "o": {On: traceOnCommandFlag},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.CompoundShortFlag{ &argh.CompoundShortFlag{
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "c"}, &argh.CommandFlag{Name: "c"},
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
}, },
}, },
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.CompoundShortFlag{ &argh.CompoundShortFlag{
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "b"}, &argh.CommandFlag{Name: "b"},
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
&argh.Flag{Name: "o"}, &argh.CommandFlag{Name: "o"},
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
}, },
}, },
}, },
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "c"}, &argh.CommandFlag{Name: "c"},
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "b"}, &argh.CommandFlag{Name: "b"},
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
&argh.Flag{Name: "o"}, &argh.CommandFlag{Name: "o"},
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
}, },
}, },
}, },
@ -505,26 +501,26 @@ func TestParser(t *testing.T) {
Commands: &argh.Commands{Map: map[string]argh.CommandConfig{}}, Commands: &argh.Commands{Map: map[string]argh.CommandConfig{}},
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"a": {On: traceOnFlag}, "a": {On: traceOnCommandFlag},
"b": argh.FlagConfig{NValue: 1, On: traceOnFlag}, "b": argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
"ca": {On: traceOnFlag}, "ca": {On: traceOnCommandFlag},
"l": {On: traceOnFlag}, "l": {On: traceOnCommandFlag},
"o": {On: traceOnFlag}, "o": {On: traceOnCommandFlag},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "ca"}, &argh.CommandFlag{Name: "ca"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{ &argh.CommandFlag{
Name: "b", Name: "b",
Values: map[string]string{"0": "1312"}, Values: map[string]string{"0": "1312"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -535,30 +531,30 @@ func TestParser(t *testing.T) {
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.CompoundShortFlag{ &argh.CompoundShortFlag{
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
&argh.Flag{Name: "o"}, &argh.CommandFlag{Name: "o"},
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
}, },
}, },
}, },
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "ca"}, &argh.CommandFlag{Name: "ca"},
&argh.Flag{ &argh.CommandFlag{
Name: "b", Name: "b",
Values: map[string]string{"0": "1312"}, Values: map[string]string{"0": "1312"},
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Ident{Literal: "1312"}, &argh.Ident{Literal: "1312"},
}, },
}, },
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
&argh.Flag{Name: "o"}, &argh.CommandFlag{Name: "o"},
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
}, },
}, },
}, },
@ -576,7 +572,7 @@ func TestParser(t *testing.T) {
"fry": argh.CommandConfig{ "fry": argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"forever": {On: traceOnFlag}, "forever": {On: traceOnCommandFlag},
}, },
}, },
}, },
@ -586,15 +582,15 @@ func TestParser(t *testing.T) {
}, },
}, },
Flags: &argh.Flags{Map: map[string]argh.FlagConfig{}}, Flags: &argh.Flags{Map: map[string]argh.FlagConfig{}},
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Command{ &argh.CommandFlag{
Name: "fly", Name: "fly",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
@ -608,13 +604,13 @@ func TestParser(t *testing.T) {
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Ident{Literal: "times"}, &argh.Ident{Literal: "times"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Command{ &argh.CommandFlag{
Name: "fry", Name: "fry",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Ident{Literal: "deeply"}, &argh.Ident{Literal: "deeply"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "forever"}, &argh.CommandFlag{Name: "forever"},
}, },
}, },
}, },
@ -623,10 +619,10 @@ func TestParser(t *testing.T) {
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "fly", Name: "fly",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Ident{Literal: "freely"}, &argh.Ident{Literal: "freely"},
@ -634,11 +630,11 @@ func TestParser(t *testing.T) {
&argh.Ident{Literal: "and"}, &argh.Ident{Literal: "and"},
&argh.Ident{Literal: "other"}, &argh.Ident{Literal: "other"},
&argh.Ident{Literal: "times"}, &argh.Ident{Literal: "times"},
&argh.Command{ &argh.CommandFlag{
Name: "fry", Name: "fry",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Ident{Literal: "deeply"}, &argh.Ident{Literal: "deeply"},
&argh.Flag{Name: "forever"}, &argh.CommandFlag{Name: "forever"},
}, },
}, },
}, },
@ -654,29 +650,29 @@ func TestParser(t *testing.T) {
Prog: &argh.CommandConfig{ Prog: &argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"a": {NValue: argh.ZeroOrMoreValue, On: traceOnFlag}, "a": {NValue: argh.ZeroOrMoreValue, On: traceOnCommandFlag},
"d": {NValue: argh.OneOrMoreValue, On: traceOnFlag}, "d": {NValue: argh.OneOrMoreValue, On: traceOnCommandFlag},
"e": {On: traceOnFlag}, "e": {On: traceOnCommandFlag},
"l": {On: traceOnFlag}, "l": {On: traceOnCommandFlag},
"n": {On: traceOnFlag}, "n": {On: traceOnCommandFlag},
"o": {NValue: 1, ValueNames: []string{"level"}, On: traceOnFlag}, "o": {NValue: 1, ValueNames: []string{"level"}, On: traceOnCommandFlag},
"s": {NValue: argh.ZeroOrMoreValue, On: traceOnFlag}, "s": {NValue: argh.ZeroOrMoreValue, On: traceOnCommandFlag},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.CompoundShortFlag{ &argh.CompoundShortFlag{
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "n"}, &argh.CommandFlag{Name: "n"},
&argh.Flag{Name: "e"}, &argh.CommandFlag{Name: "e"},
&argh.Flag{Name: "e"}, &argh.CommandFlag{Name: "e"},
&argh.Flag{ &argh.CommandFlag{
Name: "d", Name: "d",
Values: map[string]string{ Values: map[string]string{
"0": "sauce", "0": "sauce",
@ -697,10 +693,10 @@ func TestParser(t *testing.T) {
}, },
&argh.CompoundShortFlag{ &argh.CompoundShortFlag{
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
&argh.Flag{Name: "s"}, &argh.CommandFlag{Name: "s"},
&argh.Flag{ &argh.CommandFlag{
Name: "o", Name: "o",
Values: map[string]string{ Values: map[string]string{
"level": "over9000", "level": "over9000",
@ -716,13 +712,13 @@ func TestParser(t *testing.T) {
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "n"}, &argh.CommandFlag{Name: "n"},
&argh.Flag{Name: "e"}, &argh.CommandFlag{Name: "e"},
&argh.Flag{Name: "e"}, &argh.CommandFlag{Name: "e"},
&argh.Flag{ &argh.CommandFlag{
Name: "d", Name: "d",
Values: map[string]string{ Values: map[string]string{
"0": "sauce", "0": "sauce",
@ -735,10 +731,10 @@ func TestParser(t *testing.T) {
&argh.Ident{Literal: "love"}, &argh.Ident{Literal: "love"},
}, },
}, },
&argh.Flag{Name: "a"}, &argh.CommandFlag{Name: "a"},
&argh.Flag{Name: "l"}, &argh.CommandFlag{Name: "l"},
&argh.Flag{Name: "s"}, &argh.CommandFlag{Name: "s"},
&argh.Flag{ &argh.CommandFlag{
Name: "o", Name: "o",
Values: map[string]string{ Values: map[string]string{
"level": "over9000", "level": "over9000",
@ -761,7 +757,7 @@ func TestParser(t *testing.T) {
"fly": argh.CommandConfig{ "fly": argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"freely": {On: traceOnFlag}, "freely": {On: traceOnCommandFlag},
}, },
}, },
Commands: &argh.Commands{ Commands: &argh.Commands{
@ -769,10 +765,10 @@ func TestParser(t *testing.T) {
"fry": argh.CommandConfig{ "fry": argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"deeply": {On: traceOnFlag}, "deeply": {On: traceOnCommandFlag},
"w": {On: traceOnFlag}, "w": {On: traceOnCommandFlag},
"A": {On: traceOnFlag}, "A": {On: traceOnCommandFlag},
"t": argh.FlagConfig{NValue: 1, On: traceOnFlag}, "t": argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
}, },
}, },
}, },
@ -782,31 +778,31 @@ func TestParser(t *testing.T) {
}, },
}, },
Flags: &argh.Flags{Map: map[string]argh.FlagConfig{}}, Flags: &argh.Flags{Map: map[string]argh.FlagConfig{}},
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Command{ &argh.CommandFlag{
Name: "fly", Name: "fly",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "freely"}, &argh.CommandFlag{Name: "freely"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Command{ &argh.CommandFlag{
Name: "fry", Name: "fry",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "deeply"}, &argh.CommandFlag{Name: "deeply"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.CompoundShortFlag{ &argh.CompoundShortFlag{
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "w"}, &argh.CommandFlag{Name: "w"},
&argh.Flag{Name: "A"}, &argh.CommandFlag{Name: "A"},
&argh.Flag{ &argh.CommandFlag{
Name: "t", Name: "t",
Values: map[string]string{"0": "hugs"}, Values: map[string]string{"0": "hugs"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -824,20 +820,20 @@ func TestParser(t *testing.T) {
}, },
}, },
expAST: []argh.Node{ expAST: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "fly", Name: "fly",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "freely"}, &argh.CommandFlag{Name: "freely"},
&argh.Command{ &argh.CommandFlag{
Name: "fry", Name: "fry",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "deeply"}, &argh.CommandFlag{Name: "deeply"},
&argh.Flag{Name: "w"}, &argh.CommandFlag{Name: "w"},
&argh.Flag{Name: "A"}, &argh.CommandFlag{Name: "A"},
&argh.Flag{ &argh.CommandFlag{
Name: "t", Name: "t",
Values: map[string]string{"0": "hugs"}, Values: map[string]string{"0": "hugs"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -863,7 +859,7 @@ func TestParser(t *testing.T) {
NValue: 1, NValue: 1,
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"FIERCENESS": argh.FlagConfig{NValue: 1, On: traceOnFlag}, "FIERCENESS": argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
}, },
}, },
}, },
@ -871,13 +867,13 @@ func TestParser(t *testing.T) {
}, },
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"w": {On: traceOnFlag}, "w": {On: traceOnCommandFlag},
"A": {On: traceOnFlag}, "A": {On: traceOnCommandFlag},
"T": {NValue: 1, On: traceOnFlag}, "T": {NValue: 1, On: traceOnCommandFlag},
"hecKing": {On: traceOnFlag}, "hecKing": {On: traceOnCommandFlag},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
ScannerConfig: &argh.ScannerConfig{ ScannerConfig: &argh.ScannerConfig{
AssignmentOperator: '@', AssignmentOperator: '@',
@ -886,15 +882,15 @@ func TestParser(t *testing.T) {
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "PIZZAs", Name: "PIZZAs",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.CompoundShortFlag{ &argh.CompoundShortFlag{
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.Flag{Name: "w"}, &argh.CommandFlag{Name: "w"},
&argh.Flag{Name: "A"}, &argh.CommandFlag{Name: "A"},
&argh.Flag{ &argh.CommandFlag{
Name: "T", Name: "T",
Values: map[string]string{"0": "golf"}, Values: map[string]string{"0": "golf"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -905,16 +901,16 @@ func TestParser(t *testing.T) {
}, },
}, },
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "hecKing"}, &argh.CommandFlag{Name: "hecKing"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Command{ &argh.CommandFlag{
Name: "goose", Name: "goose",
Values: map[string]string{"0": "bonk"}, Values: map[string]string{"0": "bonk"},
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Ident{Literal: "bonk"}, &argh.Ident{Literal: "bonk"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{ &argh.CommandFlag{
Name: "FIERCENESS", Name: "FIERCENESS",
Values: map[string]string{"0": "-2"}, Values: map[string]string{"0": "-2"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -935,9 +931,9 @@ func TestParser(t *testing.T) {
Prog: &argh.CommandConfig{ Prog: &argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"f": {On: traceOnFlag}, "f": {On: traceOnCommandFlag},
"L": {On: traceOnFlag}, "L": {On: traceOnCommandFlag},
"o": argh.FlagConfig{NValue: 1, On: traceOnFlag}, "o": argh.FlagConfig{NValue: 1, On: traceOnCommandFlag},
}, },
}, },
Commands: &argh.Commands{ Commands: &argh.Commands{
@ -945,7 +941,7 @@ func TestParser(t *testing.T) {
"hats": {}, "hats": {},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
ScannerConfig: &argh.ScannerConfig{ ScannerConfig: &argh.ScannerConfig{
AssignmentOperator: ':', AssignmentOperator: ':',
@ -954,15 +950,15 @@ func TestParser(t *testing.T) {
}, },
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "hotdog", Name: "hotdog",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "f"}, &argh.CommandFlag{Name: "f"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "L"}, &argh.CommandFlag{Name: "L"},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{ &argh.CommandFlag{
Name: "o", Name: "o",
Values: map[string]string{"0": "ppy"}, Values: map[string]string{"0": "ppy"},
Nodes: []argh.Node{ Nodes: []argh.Node{
@ -971,7 +967,7 @@ func TestParser(t *testing.T) {
}, },
}, },
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Command{Name: "hats"}, &argh.CommandFlag{Name: "hats"},
}, },
}, },
}, },
@ -983,22 +979,22 @@ func TestParser(t *testing.T) {
Prog: &argh.CommandConfig{ Prog: &argh.CommandConfig{
Flags: &argh.Flags{ Flags: &argh.Flags{
Map: map[string]argh.FlagConfig{ Map: map[string]argh.FlagConfig{
"wat": {On: traceOnFlag}, "wat": {On: traceOnCommandFlag},
}, },
}, },
On: traceOnCommand, On: traceOnCommandFlag,
}, },
}, },
expErr: argh.ParserErrorList{ expErr: argh.ParserErrorList{
&argh.ParserError{Pos: argh.Position{Column: 8}, Msg: "invalid bare assignment"}, &argh.ParserError{Pos: argh.Position{Column: 8}, Msg: "invalid bare assignment"},
}, },
expPT: []argh.Node{ expPT: []argh.Node{
&argh.Command{ &argh.CommandFlag{
Name: "pizzas", Name: "pizzas",
Nodes: []argh.Node{ Nodes: []argh.Node{
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.ArgDelimiter{}, &argh.ArgDelimiter{},
&argh.Flag{Name: "wat"}, &argh.CommandFlag{Name: "wat"},
}, },
}, },
}, },

Write Preview
Loading…
Cancel
Save