Collapse together Command and Flag into CommandFlag

and drop the querier

.gitignore

@@ -0,0 +1,5 @@
+*.a
+*.exe
+*.o
+*.out
+*.so

Makefile

@@ -0,0 +1,20 @@
+BENCHTIME ?= 10s
+
+.PHONY: all
+all: test
+
+.PHONY: clean
+clean:
+	rm -f coverage.out
+
+.PHONY: test
+test:
+	go test -v -coverprofile=coverage.out ./...
+
+.PHONY: bench
+bench:
+	go test -v -bench . -benchtime $(BENCHTIME) ./...
+
+.PHONY: show-cover
+show-cover:
+	go tool cover -func=coverage.out

README.md

@@ -1,4 +1,27 @@
 # argh command line parser
 
-> NOTE: much of this is lifted from
-> https://blog.gopheracademy.com/advent-2014/parsers-lexers/
+## background
+
+The Go standard library [flag](https://pkg.go.dev/flag) way of doing things has long been
+a source of frustration while implementing and maintaining the
+[urfave/cli](https://github.com/urfave/cli) library. [Many alternate parsers
+exist](https://github.com/avelino/awesome-go#standard-cli), including:
+
+- [pflag](https://github.com/spf13/pflag)
+- [argparse](https://github.com/akamensky/argparse)
+
+In addition to these other implementations, I also got some help via [this
+oldie](https://blog.gopheracademy.com/advent-2014/parsers-lexers/) and the Go standard
+library [parser](https://pkg.go.dev/go/parser).
+
+## goals
+
+- get a better understanding of the whole problem space
+- support both POSIX-y and Windows-y styles
+- build a printable/JSON-able parse tree
+- support rich error reporting
+- support event-like reactive parsing
+
+<!--
+vim:tw=90
+-->

argh.go

@@ -1,6 +1,7 @@
 package argh
 
 import (
+	"errors"
 	"fmt"
 	"log"
 	"os"
@@ -11,6 +12,8 @@ import (
 var (
 	tracingEnabled = os.Getenv("ARGH_TRACING") == "enabled"
 	traceLogger    *log.Logger
+
+	Error = errors.New("argh error")
 )
 
 func init() {

argh_test.go

@@ -0,0 +1,181 @@
+package argh_test
+
+import (
+	"flag"
+	"fmt"
+	"strconv"
+	"testing"
+	"time"
+
+	"git.meatballhat.com/x/argh"
+)
+
+func ptrTo[T any](v T) *T {
+	return &v
+}
+
+func ptrFrom[T any](v *T) T {
+	if v != nil {
+		return *v
+	}
+
+	var zero T
+	return zero
+}
+
+func BenchmarkStdlibFlag(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		func() {
+			fl := flag.NewFlagSet("bench", flag.PanicOnError)
+			okFlag := fl.Bool("ok", false, "")
+			durFlag := fl.Duration("dur", time.Second, "")
+			f64Flag := fl.Float64("f64", float64(42.0), "")
+			iFlag := fl.Int("i", -11, "")
+			i64Flag := fl.Int64("i64", -111111111111, "")
+			sFlag := fl.String("s", "hello", "")
+			uFlag := fl.Uint("u", 11, "")
+			u64Flag := fl.Uint64("u64", 11111111111111111111, "")
+
+			_ = fl.Parse([]string{
+				"-ok",
+				"-dur", "42h42m10s",
+				"-f64", "4242424242.42",
+				"-i", "-42",
+				"-i64", "-4242424242",
+				"-s", "the answer",
+				"-u", "42",
+				"-u64", "4242424242",
+			})
+			_ = fmt.Sprint(
+				"fl", fl,
+				"okFlag", *okFlag,
+				"durFlag", *durFlag,
+				"f64Flag", *f64Flag,
+				"iFlag", *iFlag,
+				"i64Flag", *i64Flag,
+				"sFlag", *sFlag,
+				"uFlag", *uFlag,
+				"u64Flag", *u64Flag,
+			)
+		}()
+	}
+}
+
+func BenchmarkArgh(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		func() {
+			var (
+				okFlag  *bool
+				durFlag *time.Duration
+				f64Flag *float64
+				iFlag   *int
+				i64Flag *int64
+				sFlag   *string
+				uFlag   *uint
+				u64Flag *uint64
+			)
+
+			pCfg := argh.NewParserConfig()
+			pCfg.Prog = &argh.CommandConfig{
+				Flags: &argh.Flags{
+					Map: map[string]argh.FlagConfig{
+						"ok": {
+							On: func(fl argh.CommandFlag) {
+								okFlag = ptrTo(true)
+							},
+						},
+						"dur": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if pt, err := time.ParseDuration(v); err != nil {
+										durFlag = ptrTo(pt)
+									}
+								}
+							},
+						},
+						"f64": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if f, err := strconv.ParseFloat(v, 64); err == nil {
+										f64Flag = ptrTo(f)
+									}
+								}
+							},
+						},
+						"i": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if i, err := strconv.ParseInt(v, 10, 64); err == nil {
+										iFlag = ptrTo(int(i))
+									}
+								}
+							},
+						},
+						"i64": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if i, err := strconv.ParseInt(v, 10, 64); err == nil {
+										i64Flag = ptrTo(i)
+									}
+								}
+							},
+						},
+						"s": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									sFlag = ptrTo(v)
+								}
+							},
+						},
+						"u": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if u, err := strconv.ParseUint(v, 10, 64); err == nil {
+										uFlag = ptrTo(uint(u))
+									}
+								}
+							},
+						},
+						"u64": {
+							NValue: 1,
+							On: func(fl argh.CommandFlag) {
+								if v, ok := fl.Values["0"]; ok {
+									if u, err := strconv.ParseUint(v, 10, 64); err == nil {
+										u64Flag = ptrTo(u)
+									}
+								}
+							},
+						},
+					},
+				},
+			}
+
+			_, _ = argh.ParseArgs([]string{
+				"--ok",
+				"--dur", "42h42m10s",
+				"--f64", "4242424242.42",
+				"-i", "-42",
+				"--i64", "-4242424242",
+				"-s", "the answer",
+				"-u", "42",
+				"--u64", "4242424242",
+			}, pCfg)
+			_ = fmt.Sprint(
+				"okFlag", ptrFrom(okFlag),
+				"durFlag", ptrFrom(durFlag),
+				"f64Flag", ptrFrom(f64Flag),
+				"iFlag", ptrFrom(iFlag),
+				"i64Flag", ptrFrom(i64Flag),
+				"sFlag", ptrFrom(sFlag),
+				"uFlag", ptrFrom(uFlag),
+				"u64Flag", ptrFrom(u64Flag),
+			)
+		}()
+	}
+}

ast.go

@@ -0,0 +1,50 @@
+package argh
+
+// ToAST accepts a slice of nodes as expected from ParseArgs and
+// returns an AST with parse-time artifacts dropped and reorganized
+// where applicable.
+func ToAST(parseTree []Node) []Node {
+	ret := []Node{}
+
+	for i, node := range parseTree {
+		tracef("ToAST i=%d node type=%T", i, node)
+
+		if _, ok := node.(*ArgDelimiter); ok {
+			continue
+		}
+
+		if _, ok := node.(*StopFlag); ok {
+			continue
+		}
+
+		if v, ok := node.(*CompoundShortFlag); ok {
+			if v.Nodes != nil {
+				ret = append(ret, ToAST(v.Nodes)...)
+			}
+
+			continue
+		}
+
+		if v, ok := node.(*CommandFlag); ok {
+			astNodes := ToAST(v.Nodes)
+
+			if len(astNodes) == 0 {
+				astNodes = nil
+			}
+
+			ret = append(
+				ret,
+				&CommandFlag{
+					Name:   v.Name,
+					Values: v.Values,
+					Nodes:  astNodes,
+				})
+
+			continue
+		}
+
+		ret = append(ret, node)
+	}
+
+	return ret
+}

cmd/argh-example/main.go

@@ -6,7 +6,7 @@ import (
 	"log"
 	"os"
 
-	"git.meatballhat.com/x/box-o-sand/argh"
+	"git.meatballhat.com/x/argh"
 	"github.com/davecgh/go-spew/spew"
 )
 
@@ -15,21 +15,21 @@ func main() {
 
 	log.SetFlags(0)
 
-	pt, err := argh.ParseArgs(os.Args, argh.NewParserConfig(
-		&argh.CommandConfig{
-			NValue:     argh.OneOrMoreValue,
-			ValueNames: []string{"topping"},
-			Flags: &argh.Flags{
-				Automatic: true,
-			},
+	pCfg := argh.NewParserConfig()
+	pCfg.Prog = &argh.CommandConfig{
+		NValue:     argh.OneOrMoreValue,
+		ValueNames: []string{"val"},
+		Flags: &argh.Flags{
+			Automatic: true,
 		},
-		nil,
-	))
+	}
+
+	pt, err := argh.ParseArgs(os.Args, pCfg)
 	if err != nil {
 		log.Fatal(err)
 	}
 
-	ast := argh.NewQuerier(pt.Nodes).AST()
+	ast := argh.ToAST(pt.Nodes)
 
 	if asJSON {
 		b, err := json.MarshalIndent(ast, "", "  ")

go.mod

@@ -1,12 +1,13 @@
-module git.meatballhat.com/x/box-o-sand/argh
+module git.meatballhat.com/x/argh
 
 go 1.18
 
-require github.com/pkg/errors v0.9.1
+require (
+	github.com/davecgh/go-spew v1.1.1
+	github.com/stretchr/testify v1.8.0
+)
 
 require (
-	github.com/davecgh/go-spew v1.1.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/stretchr/testify v1.7.1 // indirect
-	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,12 +1,15 @@
-github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

node.go

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

parser.go

@@ -26,10 +26,13 @@ type ParseTree struct {
 
 func ParseArgs(args []string, pCfg *ParserConfig) (*ParseTree, error) {
 	p := &parser{}
-	p.init(
+
+	if err := p.init(
 		strings.NewReader(strings.Join(args, string(nul))),
 		pCfg,
-	)
+	); err != nil {
+		return nil, err
+	}
 
 	tracef("ParseArgs(...) parser=%+#v", p)
 
@@ -40,11 +43,11 @@ func (p *parser) addError(msg string) {
 	p.errors.Add(Position{Column: int(p.pos)}, msg)
 }
 
-func (p *parser) init(r io.Reader, pCfg *ParserConfig) {
+func (p *parser) init(r io.Reader, pCfg *ParserConfig) error {
 	p.errors = ParserErrorList{}
 
 	if pCfg == nil {
-		pCfg = POSIXyParserConfig
+		return fmt.Errorf("nil parser config: %w", Error)
 	}
 
 	p.cfg = pCfg
@@ -52,6 +55,8 @@ func (p *parser) init(r io.Reader, pCfg *ParserConfig) {
 	p.s = NewScanner(r, pCfg.ScannerConfig)
 
 	p.next()
+
+	return nil
 }
 
 func (p *parser) parseArgs() (*ParseTree, error) {
@@ -61,7 +66,7 @@ func (p *parser) parseArgs() (*ParseTree, error) {
 	}
 
 	tracef("parseArgs() parsing %q as program command; cfg=%+#v", p.lit, p.cfg.Prog)
-	prog := p.parseCommand(&p.cfg.Prog)
+	prog := p.parseCommand(p.cfg.Prog)
 
 	tracef("parseArgs() top level node is %T", prog)
 
@@ -87,7 +92,7 @@ func (p *parser) next() {
 func (p *parser) parseCommand(cCfg *CommandConfig) Node {
 	tracef("parseCommand(%+#v)", cCfg)
 
-	node := &Command{
+	node := &CommandFlag{
 		Name: p.lit,
 	}
 	values := map[string]string{}
@@ -179,6 +184,13 @@ func (p *parser) parseCommand(cCfg *CommandConfig) Node {
 		node.Values = values
 	}
 
+	if cCfg.On != nil {
+		tracef("parseCommand(...) calling command config handler for node=%+#v", node)
+		cCfg.On(*node)
+	} else {
+		tracef("parseCommand(...) no command config handler for node=%+#v", node)
+	}
+
 	tracef("parseCommand(...) returning node=%+#v", node)
 	return node
 }
@@ -205,65 +217,115 @@ func (p *parser) parseFlag(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)
 	if !ok {
-		p.addError(fmt.Sprintf("unknown flag %q", node.Name))
+		p.addError(fmt.Sprintf("unknown flag %[1]q", node.Name))
 
 		return node
 	}
 
-	return p.parseConfiguredFlag(node, flCfg)
+	return p.parseConfiguredFlag(node, flCfg, nil)
 }
 
 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)
 	if !ok {
-		p.addError(fmt.Sprintf("unknown flag %q", node.Name))
+		p.addError(fmt.Sprintf("unknown flag %[1]q", node.Name))
 
 		return node
 	}
 
-	return p.parseConfiguredFlag(node, flCfg)
+	return p.parseConfiguredFlag(node, flCfg, nil)
 }
 
 func (p *parser) parseCompoundShortFlag(flags *Flags) Node {
-	flagNodes := []Node{}
+	unparsedFlags := []*CommandFlag{}
+	unparsedFlagConfigs := []FlagConfig{}
 
 	withoutFlagPrefix := p.lit[1:]
 
-	for i, r := range withoutFlagPrefix {
-		node := &Flag{Name: string(r)}
+	for _, r := range withoutFlagPrefix {
+		node := &CommandFlag{Name: string(r)}
 
-		if i == len(withoutFlagPrefix)-1 {
-			flCfg, ok := flags.Get(node.Name)
-			if !ok {
-				p.addError(fmt.Sprintf("unknown flag %q", node.Name))
-
-				continue
-			}
-
-			flagNodes = append(flagNodes, p.parseConfiguredFlag(node, flCfg))
+		flCfg, ok := flags.Get(node.Name)
+		if !ok {
+			p.addError(fmt.Sprintf("unknown flag %[1]q", node.Name))
 
 			continue
 		}
 
-		flagNodes = append(flagNodes, node)
+		unparsedFlags = append(unparsedFlags, node)
+		unparsedFlagConfigs = append(unparsedFlagConfigs, flCfg)
+	}
+
+	flagNodes := []Node{}
+
+	for i, node := range unparsedFlags {
+		flCfg := unparsedFlagConfigs[i]
+
+		if i != len(unparsedFlags)-1 {
+			// NOTE: if a compound short flag is configured to accept
+			// more than zero values but is not the last flag in the
+			// group, it will be parsed with an override NValue of
+			// ZeroValue so that it does not consume the next token.
+			if flCfg.NValue.Required() {
+				p.addError(
+					fmt.Sprintf(
+						"short flag %[1]q before end of compound group expects value",
+						node.Name,
+					),
+				)
+			}
+
+			flagNodes = append(
+				flagNodes,
+				p.parseConfiguredFlag(node, flCfg, zeroValuePtr),
+			)
+
+			continue
+		}
+
+		flagNodes = append(flagNodes, p.parseConfiguredFlag(node, flCfg, nil))
 	}
 
 	return &CompoundShortFlag{Nodes: flagNodes}
 }
 
-func (p *parser) parseConfiguredFlag(node *Flag, flCfg FlagConfig) Node {
+func (p *parser) parseConfiguredFlag(node *CommandFlag, flCfg FlagConfig, nValueOverride *NValue) Node {
 	values := map[string]string{}
 	nodes := []Node{}
 
+	atExit := func() *CommandFlag {
+		if len(nodes) > 0 {
+			node.Nodes = nodes
+		}
+
+		if len(values) > 0 {
+			node.Values = values
+		}
+
+		if flCfg.On != nil {
+			tracef("parseConfiguredFlag(...) calling flag config handler for node=%+#[1]v", node)
+			flCfg.On(*node)
+		} else {
+			tracef("parseConfiguredFlag(...) no flag config handler for node=%+#[1]v", node)
+		}
+
+		return node
+	}
+
 	identIndex := 0
 
 	for i := 0; p.tok != EOL; i++ {
+		if nValueOverride != nil && !(*nValueOverride).Contains(identIndex) {
+			tracef("parseConfiguredFlag(...) identIndex=%d exceeds expected=%v; breaking", identIndex, *nValueOverride)
+			break
+		}
+
 		if !flCfg.NValue.Contains(identIndex) {
 			tracef("parseConfiguredFlag(...) identIndex=%d exceeds expected=%v; breaking", identIndex, flCfg.NValue)
 			break
@@ -308,27 +370,11 @@ func (p *parser) parseConfiguredFlag(node *Flag, flCfg FlagConfig) Node {
 			tracef("parseConfiguredFlag(...) breaking on %s %q %v; setting buffered=true", p.tok, p.lit, p.pos)
 			p.buffered = true
 
-			if len(nodes) > 0 {
-				node.Nodes = nodes
-			}
-
-			if len(values) > 0 {
-				node.Values = values
-			}
-
-			return node
+			return atExit()
 		}
 	}
 
-	if len(nodes) > 0 {
-		node.Nodes = nodes
-	}
-
-	if len(values) > 0 {
-		node.Values = values
-	}
-
-	return node
+	return atExit()
 }
 
 func (p *parser) parsePassthrough() Node {

parser_config.go

@@ -7,14 +7,22 @@ const (
 )
 
 var (
-	POSIXyParserConfig = NewParserConfig(
-		nil,
-		POSIXyScannerConfig,
-	)
+	zeroValuePtr = func() *NValue {
+		v := ZeroValue
+		return &v
+	}()
 )
 
 type NValue int
 
+func (nv NValue) Required() bool {
+	if nv == OneOrMoreValue {
+		return true
+	}
+
+	return int(nv) >= 1
+}
+
 func (nv NValue) Contains(i int) bool {
 	tracef("NValue.Contains(%v)", i)
 
@@ -30,25 +38,29 @@ func (nv NValue) Contains(i int) bool {
 }
 
 type ParserConfig struct {
-	Prog CommandConfig
+	Prog *CommandConfig
 
 	ScannerConfig *ScannerConfig
 }
 
-func NewParserConfig(prog *CommandConfig, sCfg *ScannerConfig) *ParserConfig {
-	if sCfg == nil {
-		sCfg = POSIXyScannerConfig
+type ParserOption func(*ParserConfig)
+
+func NewParserConfig(opts ...ParserOption) *ParserConfig {
+	pCfg := &ParserConfig{}
+
+	for _, opt := range opts {
+		if opt != nil {
+			opt(pCfg)
+		}
 	}
 
-	if prog == nil {
-		prog = &CommandConfig{}
+	if pCfg.Prog == nil {
+		pCfg.Prog = &CommandConfig{}
+		pCfg.Prog.init()
 	}
 
-	prog.init()
-
-	pCfg := &ParserConfig{
-		Prog:          *prog,
-		ScannerConfig: sCfg,
+	if pCfg.ScannerConfig == nil {
+		pCfg.ScannerConfig = POSIXyScannerConfig
 	}
 
 	return pCfg
@@ -59,6 +71,8 @@ type CommandConfig struct {
 	ValueNames []string
 	Flags      *Flags
 	Commands   *Commands
+
+	On func(CommandFlag)
 }
 
 func (cCfg *CommandConfig) init() {
@@ -99,6 +113,8 @@ type FlagConfig struct {
 	NValue     NValue
 	Persist    bool
 	ValueNames []string
+
+	On func(CommandFlag)
 }
 
 type Flags struct {

querier.go

@@ -1,94 +0,0 @@
-package argh
-
-type Querier interface {
-	Program() (*Command, bool)
-	AST() []Node
-}
-
-func NewQuerier(nodes []Node) Querier {
-	return &defaultQuerier{nodes: nodes}
-}
-
-type defaultQuerier struct {
-	nodes []Node
-}
-
-func (dq *defaultQuerier) Program() (*Command, bool) {
-	if len(dq.nodes) == 0 {
-		tracef("Program nodes are empty")
-		return nil, false
-	}
-
-	tracef("Program node[0] is %T", dq.nodes[0])
-
-	v, ok := dq.nodes[0].(*Command)
-	if ok && v.Name == "" {
-		return v, false
-	}
-
-	return v, ok
-}
-
-func (dq *defaultQuerier) AST() []Node {
-	ret := []Node{}
-
-	for i, node := range dq.nodes {
-		tracef("AST i=%d node type=%T", i, node)
-
-		if _, ok := node.(*ArgDelimiter); ok {
-			continue
-		}
-
-		if _, ok := node.(*StopFlag); ok {
-			continue
-		}
-
-		if v, ok := node.(*CompoundShortFlag); ok {
-			if v.Nodes != nil {
-				ret = append(ret, NewQuerier(v.Nodes).AST()...)
-			}
-
-			continue
-		}
-
-		if v, ok := node.(*Command); ok {
-			astNodes := NewQuerier(v.Nodes).AST()
-
-			if len(astNodes) == 0 {
-				astNodes = nil
-			}
-
-			ret = append(
-				ret,
-				&Command{
-					Name:   v.Name,
-					Values: v.Values,
-					Nodes:  astNodes,
-				})
-
-			continue
-		}
-
-		if v, ok := node.(*Flag); ok {
-			astNodes := NewQuerier(v.Nodes).AST()
-
-			if len(astNodes) == 0 {
-				astNodes = nil
-			}
-
-			ret = append(
-				ret,
-				&Flag{
-					Name:   v.Name,
-					Values: v.Values,
-					Nodes:  astNodes,
-				})
-
-			continue
-		}
-
-		ret = append(ret, node)
-	}
-
-	return ret
-}

querier_test.go

@@ -1,60 +0,0 @@
-package argh_test
-
-import (
-	"testing"
-
-	"git.meatballhat.com/x/box-o-sand/argh"
-	"github.com/stretchr/testify/require"
-)
-
-func TestQuerier_Program(t *testing.T) {
-	for _, tc := range []struct {
-		name  string
-		args  []string
-		cfg   *argh.ParserConfig
-		exp   string
-		expOK bool
-	}{
-		{
-			name: "typical",
-			args: []string{"pizzas", "ahoy", "--treatsa", "fun"},
-			cfg: &argh.ParserConfig{
-				Prog: argh.CommandConfig{
-					Commands: &argh.Commands{
-						Map: map[string]argh.CommandConfig{
-							"ahoy": argh.CommandConfig{
-								Flags: &argh.Flags{
-									Map: map[string]argh.FlagConfig{
-										"treatsa": argh.FlagConfig{NValue: 1},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-			exp:   "pizzas",
-			expOK: true,
-		},
-		{
-			name:  "minimal",
-			args:  []string{"pizzas"},
-			exp:   "pizzas",
-			expOK: true,
-		},
-		{
-			name:  "invalid",
-			args:  []string{},
-			expOK: false,
-		},
-	} {
-		t.Run(tc.name, func(ct *testing.T) {
-			pt, err := argh.ParseArgs(tc.args, tc.cfg)
-			require.Nil(ct, err)
-
-			prog, ok := argh.NewQuerier(pt.Nodes).Program()
-			require.Equal(ct, tc.expOK, ok)
-			require.Equal(ct, tc.exp, prog.Name)
-		})
-	}
-}

scanner_test.go

@@ -0,0 +1,83 @@
+package argh
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+func BenchmarkScannerPOSIXyScannerScan(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		scanner := NewScanner(strings.NewReader(strings.Join([]string{
+			"walrus",
+			"-what",
+			"--ball=awesome",
+			"--elapsed",
+			"carrot cake",
+		}, string(nul))), nil)
+		for {
+			tok, _, _ := scanner.Scan()
+			if tok == EOL {
+				break
+			}
+		}
+	}
+}
+
+func TestScannerPOSIXyScanner(t *testing.T) {
+	for _, tc := range []struct {
+		name              string
+		argv              []string
+		expectedTokens    []Token
+		expectedLiterals  []string
+		expectedPositions []Pos
+	}{
+		{
+			name: "simple",
+			argv: []string{"walrus", "-cake", "--corn-dog", "awkward"},
+			expectedTokens: []Token{
+				IDENT,
+				ARG_DELIMITER,
+				COMPOUND_SHORT_FLAG,
+				ARG_DELIMITER,
+				LONG_FLAG,
+				ARG_DELIMITER,
+				IDENT,
+				EOL,
+			},
+			expectedLiterals: []string{
+				"walrus", string(nul), "-cake", string(nul), "--corn-dog", string(nul), "awkward", "",
+			},
+			expectedPositions: []Pos{
+				6, 7, 12, 13, 23, 24, 31, 32,
+			},
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			r := require.New(t)
+
+			scanner := NewScanner(strings.NewReader(strings.Join(tc.argv, string(nul))), nil)
+
+			actualTokens := []Token{}
+			actualLiterals := []string{}
+			actualPositions := []Pos{}
+
+			for {
+				tok, lit, pos := scanner.Scan()
+
+				actualTokens = append(actualTokens, tok)
+				actualLiterals = append(actualLiterals, lit)
+				actualPositions = append(actualPositions, pos)
+
+				if tok == EOL {
+					break
+				}
+			}
+
+			r.Equal(tc.expectedTokens, actualTokens)
+			r.Equal(tc.expectedLiterals, actualLiterals)
+			r.Equal(tc.expectedPositions, actualPositions)
+		})
+	}
+}