Making more messes with parser config

and ensuring all unknown ident/stdin nodes are retained

argh/argh.go

@@ -26,7 +26,7 @@ func tracef(format string, v ...any) {
 		return
 	}
 
-	if _, file, line, ok := runtime.Caller(2); ok {
+	if _, file, line, ok := runtime.Caller(1); ok {
 		format = fmt.Sprintf("%v:%v ", filepath.Base(file), line) + format
 	}
 

argh/cmd/argh-example/main.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+
+	"git.meatballhat.com/x/box-o-sand/argh"
+	"github.com/davecgh/go-spew/spew"
+)
+
+func main() {
+	asJSON := os.Getenv("ARGH_OUTPUT_JSON") == "enabled"
+
+	log.SetFlags(0)
+
+	pt, err := argh.ParseArgs(os.Args, argh.NewParserConfig(
+		&argh.CommandConfig{
+			NValue:     argh.OneOrMoreValue,
+			ValueNames: []string{"topping"},
+			Flags: &argh.Flags{
+				Automatic: true,
+			},
+		},
+		nil,
+	))
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	ast := argh.NewQuerier(pt.Nodes).AST()
+
+	if asJSON {
+		b, err := json.MarshalIndent(ast, "", "  ")
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		fmt.Println(string(b))
+
+		return
+	}
+
+	spew.Dump(ast)
+}

argh/cmd/argh/main.go

@@ -1,26 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"log"
-	"os"
-
-	"git.meatballhat.com/x/box-o-sand/argh"
-)
-
-func main() {
-	log.SetFlags(0)
-
-	ast, err := argh.ParseArgs(os.Args, nil)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	b, err := json.MarshalIndent(ast, "", "  ")
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	fmt.Println(string(b))
-}

argh/node.go

@@ -3,26 +3,20 @@ package argh
 type Node interface{}
 
 type TypedNode struct {
-	Type string `json:"type"`
-	Node Node   `json:"node"`
+	Type string
+	Node Node
 }
 
 type PassthroughArgs struct {
-	Nodes []Node `json:"nodes"`
+	Nodes []Node
 }
 
 type CompoundShortFlag struct {
-	Nodes []Node `json:"nodes"`
-}
-
-type Program struct {
-	Name   string            `json:"name"`
-	Values map[string]string `json:"values"`
-	Nodes  []Node            `json:"nodes"`
+	Nodes []Node
 }
 
 type Ident struct {
-	Literal string `json:"literal"`
+	Literal string
 }
 
 type BadArg struct {
@@ -32,14 +26,15 @@ type BadArg struct {
 }
 
 type Command struct {
-	Name   string            `json:"name"`
-	Values map[string]string `json:"values"`
-	Nodes  []Node            `json:"nodes"`
+	Name   string
+	Values map[string]string
+	Nodes  []Node
 }
 
 type Flag struct {
-	Name   string            `json:"name"`
-	Values map[string]string `json:"values"`
+	Name   string
+	Values map[string]string
+	Nodes  []Node
 }
 
 type StdinFlag struct{}
@@ -47,3 +42,5 @@ type StdinFlag struct{}
 type StopFlag struct{}
 
 type ArgDelimiter struct{}
+
+type Assign struct{}

argh/parser.go

@@ -1,332 +1,346 @@
-//go:generate stringer -type NValue
-
 package argh
 
 import (
 	"fmt"
 	"io"
 	"strings"
-
-	"github.com/pkg/errors"
 )
 
-var (
-	ErrSyntax = errors.New("syntax error")
-)
-
-func ParseArgs(args []string, pCfg *ParserConfig) (*ParseTree, error) {
-	reEncoded := strings.Join(args, string(nul))
-
-	return NewParser(
-		strings.NewReader(reEncoded),
-		pCfg,
-	).Parse()
-}
-
-type Parser struct {
+type parser struct {
 	s *Scanner
 
-	buf []scanEntry
-
 	cfg *ParserConfig
 
-	nodes []Node
-	node  Node
+	errors ParserErrorList
+
+	tok Token
+	lit string
+	pos Pos
+
+	buffered bool
 }
 
 type ParseTree struct {
 	Nodes []Node `json:"nodes"`
 }
 
-type scanEntry struct {
-	tok Token
-	lit string
-	pos Pos
+func ParseArgs(args []string, pCfg *ParserConfig) (*ParseTree, error) {
+	p := &parser{}
+	p.init(
+		strings.NewReader(strings.Join(args, string(nul))),
+		pCfg,
+	)
+
+	tracef("ParseArgs(...) parser=%+#v", p)
+
+	return p.parseArgs()
 }
 
-func NewParser(r io.Reader, pCfg *ParserConfig) *Parser {
+func (p *parser) addError(msg string) {
+	p.errors.Add(Position{Column: int(p.pos)}, msg)
+}
+
+func (p *parser) init(r io.Reader, pCfg *ParserConfig) {
+	p.errors = ParserErrorList{}
+
 	if pCfg == nil {
-		pCfg = DefaultParserConfig
+		pCfg = POSIXyParserConfig
 	}
 
-	parser := &Parser{
-		buf: []scanEntry{},
-		s:   NewScanner(r, pCfg.ScannerConfig),
-		cfg: pCfg,
-	}
+	p.cfg = pCfg
 
-	tracef("NewParser parser=%+#v", parser)
-	tracef("NewParser pCfg=%+#v", pCfg)
+	p.s = NewScanner(r, pCfg.ScannerConfig)
 
-	return parser
+	p.next()
 }
 
-func (p *Parser) Parse() (*ParseTree, error) {
-	p.nodes = []Node{}
+func (p *parser) parseArgs() (*ParseTree, error) {
+	if p.errors.Len() != 0 {
+		tracef("parseArgs() bailing due to initial error")
+		return nil, p.errors.Err()
+	}
 
-	for {
-		br, err := p.parseArg()
-		if err != nil {
-			return nil, err
+	tracef("parseArgs() parsing %q as program command; cfg=%+#v", p.lit, p.cfg.Prog)
+	prog := p.parseCommand(&p.cfg.Prog)
+
+	tracef("parseArgs() top level node is %T", prog)
+
+	nodes := []Node{prog}
+	if v := p.parsePassthrough(); v != nil {
+		tracef("parseArgs() appending passthrough argument %v", v)
+		nodes = append(nodes, v)
+	}
+
+	tracef("parseArgs() returning ParseTree")
+
+	return &ParseTree{Nodes: nodes}, p.errors.Err()
+}
+
+func (p *parser) next() {
+	tracef("next() before scan: %v %q %v", p.tok, p.lit, p.pos)
+
+	p.tok, p.lit, p.pos = p.s.Scan()
+
+	tracef("next() after scan: %v %q %v", p.tok, p.lit, p.pos)
+}
+
+func (p *parser) parseCommand(cCfg *CommandConfig) Node {
+	tracef("parseCommand(%+#v)", cCfg)
+
+	node := &Command{
+		Name: p.lit,
+	}
+	values := map[string]string{}
+	nodes := []Node{}
+
+	identIndex := 0
+
+	for i := 0; p.tok != EOL; i++ {
+		if !p.buffered {
+			tracef("parseCommand(...) buffered=false; scanning next")
+			p.next()
 		}
 
-		if br {
+		p.buffered = false
+
+		tracef("parseCommand(...) for=%d values=%+#v", i, values)
+		tracef("parseCommand(...) for=%d nodes=%+#v", i, nodes)
+		tracef("parseCommand(...) for=%d tok=%s lit=%q pos=%v", i, p.tok, p.lit, p.pos)
+
+		tracef("parseCommand(...) cCfg=%+#v", cCfg)
+
+		if subCfg, ok := cCfg.GetCommandConfig(p.lit); ok {
+			subCommand := p.lit
+
+			nodes = append(nodes, p.parseCommand(&subCfg))
+
+			tracef("parseCommand(...) breaking after sub-command=%v", subCommand)
+			break
+		}
+
+		switch p.tok {
+		case ARG_DELIMITER:
+			tracef("parseCommand(...) handling %s", p.tok)
+
+			nodes = append(nodes, &ArgDelimiter{})
+
+			continue
+		case IDENT, STDIN_FLAG:
+			tracef("parseCommand(...) handling %s", p.tok)
+
+			if cCfg.NValue.Contains(identIndex) {
+				name := fmt.Sprintf("%d", identIndex)
+
+				tracef("parseCommand(...) checking for name of identIndex=%d", identIndex)
+
+				if len(cCfg.ValueNames) > identIndex {
+					name = cCfg.ValueNames[identIndex]
+					tracef("parseCommand(...) setting name=%s from config value names", name)
+				} else if len(cCfg.ValueNames) == 1 && (cCfg.NValue == OneOrMoreValue || cCfg.NValue == ZeroOrMoreValue) {
+					name = fmt.Sprintf("%s.%d", cCfg.ValueNames[0], identIndex)
+					tracef("parseCommand(...) setting name=%s from repeating value name", name)
+				}
+
+				values[name] = p.lit
+			}
+
+			if p.tok == STDIN_FLAG {
+				nodes = append(nodes, &StdinFlag{})
+			} else {
+				nodes = append(nodes, &Ident{Literal: p.lit})
+			}
+
+			identIndex++
+		case LONG_FLAG, SHORT_FLAG, COMPOUND_SHORT_FLAG:
+			tok := p.tok
+
+			flagNode := p.parseFlag(cCfg.Flags)
+
+			tracef("parseCommand(...) appending %s node=%+#v", tok, flagNode)
+
+			nodes = append(nodes, flagNode)
+		case ASSIGN:
+			tracef("parseCommand(...) error on bare %s", p.tok)
+
+			p.addError("invalid bare assignment")
+
+			break
+		default:
+			tracef("parseCommand(...) breaking on %s", p.tok)
 			break
 		}
 	}
 
-	return &ParseTree{Nodes: p.nodes}, nil
+	if len(nodes) > 0 {
+		node.Nodes = nodes
+	}
+
+	if len(values) > 0 {
+		node.Values = values
+	}
+
+	tracef("parseCommand(...) returning node=%+#v", node)
+	return node
 }
 
-func (p *Parser) parseArg() (bool, error) {
-	tok, lit, pos := p.scan()
-	if tok == ILLEGAL {
-		return false, errors.Wrapf(ErrSyntax, "illegal value %q at pos=%v", lit, pos)
-	}
-
-	if tok == EOL {
-		return true, nil
-	}
-
-	p.unscan(tok, lit, pos)
-
-	node, err := p.scanNode()
-
-	tracef("parseArg node=%+#v err=%+#v", node, err)
-
-	if err != nil {
-		return false, errors.Wrapf(err, "value %q at pos=%v", lit, pos)
-	}
-
-	if node != nil {
-		p.nodes = append(p.nodes, node)
-	}
-
-	return false, nil
+func (p *parser) parseIdent() Node {
+	node := &Ident{Literal: p.lit}
+	return node
 }
 
-func (p *Parser) scanNode() (Node, error) {
-	tok, lit, pos := p.scan()
-
-	tracef("scanNode tok=%s lit=%q pos=%v", tok, lit, pos)
-
-	switch tok {
-	case ARG_DELIMITER:
-		return ArgDelimiter{}, nil
-	case ASSIGN:
-		return nil, errors.Wrapf(ErrSyntax, "bare assignment operator at pos=%v", pos)
-	case IDENT:
-		p.unscan(tok, lit, pos)
-		return p.scanCommandOrIdent()
+func (p *parser) parseFlag(flags *Flags) Node {
+	switch p.tok {
+	case SHORT_FLAG:
+		tracef("parseFlag(...) parsing short flag with config=%+#v", flags)
+		return p.parseShortFlag(flags)
+	case LONG_FLAG:
+		tracef("parseFlag(...) parsing long flag with config=%+#v", flags)
+		return p.parseLongFlag(flags)
 	case COMPOUND_SHORT_FLAG:
-		p.unscan(tok, lit, pos)
-		return p.scanCompoundShortFlag()
-	case SHORT_FLAG, LONG_FLAG:
-		p.unscan(tok, lit, pos)
-		return p.scanFlag()
-	default:
+		tracef("parseFlag(...) parsing compound short flag with config=%+#v", flags)
+		return p.parseCompoundShortFlag(flags)
 	}
 
-	return Ident{Literal: lit}, nil
+	panic(fmt.Sprintf("token %v cannot be parsed as flag", p.tok))
 }
 
-func (p *Parser) scanCommandOrIdent() (Node, error) {
-	tok, lit, pos := p.scan()
+func (p *parser) parseShortFlag(flags *Flags) Node {
+	node := &Flag{Name: string(p.lit[1])}
 
-	if len(p.nodes) == 0 {
-		p.unscan(tok, lit, pos)
-		values, err := p.scanValues(p.cfg.Prog.NValue, p.cfg.Prog.ValueNames)
-		if err != nil {
-			return nil, err
-		}
+	flCfg, ok := flags.Get(node.Name)
+	if !ok {
+		p.addError(fmt.Sprintf("unknown flag %q", node.Name))
 
-		return Program{Name: lit, Values: values}, nil
+		return node
 	}
 
-	if cfg, ok := p.cfg.Commands[lit]; ok {
-		p.unscan(tok, lit, pos)
-		values, err := p.scanValues(cfg.NValue, cfg.ValueNames)
-		if err != nil {
-			return nil, err
-		}
-
-		return Command{Name: lit, Values: values}, nil
-	}
-
-	return Ident{Literal: lit}, nil
+	return p.parseConfiguredFlag(node, flCfg)
 }
 
-func (p *Parser) scanFlag() (Node, error) {
-	tok, lit, pos := p.scan()
+func (p *parser) parseLongFlag(flags *Flags) Node {
+	node := &Flag{Name: string(p.lit[2:])}
 
-	flagName := string(lit[1:])
-	if tok == LONG_FLAG {
-		flagName = string(lit[2:])
+	flCfg, ok := flags.Get(node.Name)
+	if !ok {
+		p.addError(fmt.Sprintf("unknown flag %q", node.Name))
+
+		return node
 	}
 
-	if cfg, ok := p.cfg.Flags[flagName]; ok {
-		p.unscan(tok, flagName, pos)
-
-		values, err := p.scanValues(cfg.NValue, cfg.ValueNames)
-		if err != nil {
-			return nil, err
-		}
-
-		return Flag{Name: flagName, Values: values}, nil
-	}
-
-	return Flag{Name: flagName}, nil
+	return p.parseConfiguredFlag(node, flCfg)
 }
 
-func (p *Parser) scanCompoundShortFlag() (Node, error) {
-	tok, lit, pos := p.scan()
-
+func (p *parser) parseCompoundShortFlag(flags *Flags) Node {
 	flagNodes := []Node{}
 
-	withoutFlagPrefix := lit[1:]
+	withoutFlagPrefix := p.lit[1:]
 
 	for i, r := range withoutFlagPrefix {
+		node := &Flag{Name: string(r)}
+
 		if i == len(withoutFlagPrefix)-1 {
-			flagName := string(r)
-
-			if cfg, ok := p.cfg.Flags[flagName]; ok {
-				p.unscan(tok, flagName, pos)
-
-				values, err := p.scanValues(cfg.NValue, cfg.ValueNames)
-				if err != nil {
-					return nil, err
-				}
-
-				flagNodes = append(flagNodes, Flag{Name: flagName, Values: values})
+			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))
+
+			continue
 		}
 
-		flagNodes = append(
-			flagNodes,
-			Flag{
-				Name: string(r),
-			},
-		)
+		flagNodes = append(flagNodes, node)
 	}
 
-	return CompoundShortFlag{Nodes: flagNodes}, nil
+	return &CompoundShortFlag{Nodes: flagNodes}
 }
 
-func (p *Parser) scanValuesAndFlags() (map[string]string, []Node, error) {
-	return nil, nil, nil
-}
+func (p *parser) parseConfiguredFlag(node *Flag, flCfg FlagConfig) Node {
+	values := map[string]string{}
+	nodes := []Node{}
 
-func (p *Parser) scanValues(n NValue, valueNames []string) (map[string]string, error) {
-	_, lit, pos := p.scan()
+	identIndex := 0
 
-	tracef("scanValues lit=%q pos=%v n=%v valueNames=%+v", lit, pos, n, valueNames)
-
-	values, err := func() (map[string]string, error) {
-		if n == ZeroValue {
-			return map[string]string{}, nil
+	for i := 0; p.tok != EOL; i++ {
+		if !flCfg.NValue.Contains(identIndex) {
+			tracef("parseConfiguredFlag(...) identIndex=%d exceeds expected=%v; breaking", identIndex, flCfg.NValue)
+			break
 		}
 
-		ret := map[string]string{}
-		i := 0
+		p.next()
 
-		for {
-			lit, err := p.scanIdent()
-			if err != nil {
-				if n == NValue(1) {
-					return nil, err
-				}
+		switch p.tok {
+		case ARG_DELIMITER:
+			nodes = append(nodes, &ArgDelimiter{})
 
-				if n == OneOrMoreValue {
-					break
-				}
+			continue
+		case ASSIGN:
+			nodes = append(nodes, &Assign{})
+
+			continue
+		case IDENT, STDIN_FLAG:
+			name := fmt.Sprintf("%d", identIndex)
+
+			tracef("parseConfiguredFlag(...) checking for name of identIndex=%d", identIndex)
+
+			if len(flCfg.ValueNames) > identIndex {
+				name = flCfg.ValueNames[identIndex]
+				tracef("parseConfiguredFlag(...) setting name=%s from config value names", name)
+			} else if len(flCfg.ValueNames) == 1 && (flCfg.NValue == OneOrMoreValue || flCfg.NValue == ZeroOrMoreValue) {
+				name = fmt.Sprintf("%s.%d", flCfg.ValueNames[0], identIndex)
+				tracef("parseConfiguredFlag(...) setting name=%s from repeating value name", name)
+			} else {
+				tracef("parseConfiguredFlag(...) setting name=%s", name)
 			}
 
-			name := fmt.Sprintf("%d", i)
-			if len(valueNames)-1 >= i {
-				name = valueNames[i]
-			} else if len(valueNames) > 0 && strings.HasSuffix(valueNames[len(valueNames)-1], "+") {
-				name = strings.TrimSuffix(valueNames[len(valueNames)-1], "+")
+			values[name] = p.lit
+
+			if p.tok == STDIN_FLAG {
+				nodes = append(nodes, &StdinFlag{})
+			} else {
+				nodes = append(nodes, &Ident{Literal: p.lit})
 			}
 
-			ret[name] = lit
+			identIndex++
+		default:
+			tracef("parseConfiguredFlag(...) breaking on %s %q %v; setting buffered=true", p.tok, p.lit, p.pos)
+			p.buffered = true
 
-			if n == NValue(1) && len(ret) == 1 {
-				break
+			if len(nodes) > 0 {
+				node.Nodes = nodes
 			}
 
-			i++
+			if len(values) > 0 {
+				node.Values = values
+			}
+
+			return node
 		}
-
-		return ret, nil
-	}()
-
-	if err != nil {
-		return nil, err
 	}
 
-	if len(values) == 0 {
-		return nil, nil
+	if len(nodes) > 0 {
+		node.Nodes = nodes
 	}
 
-	return values, nil
+	if len(values) > 0 {
+		node.Values = values
+	}
+
+	return node
 }
 
-func (p *Parser) scanIdent() (string, error) {
-	tok, lit, pos := p.scan()
+func (p *parser) parsePassthrough() Node {
+	nodes := []Node{}
 
-	tracef("scanIdent scanned tok=%s lit=%q pos=%v", tok, lit, pos)
-
-	unscanBuf := []scanEntry{}
-
-	if tok == ASSIGN || tok == ARG_DELIMITER {
-		entry := scanEntry{tok: tok, lit: lit, pos: Pos(pos)}
-
-		tracef("scanIdent tok=%s; scanning next and pushing to unscan buffer entry=%+#v", tok, entry)
-
-		unscanBuf = append([]scanEntry{entry}, unscanBuf...)
-
-		tok, lit, pos = p.scan()
+	for ; p.tok != EOL; p.next() {
+		nodes = append(nodes, &Ident{Literal: p.lit})
 	}
 
-	if tok == IDENT {
-		return lit, nil
+	if len(nodes) == 0 {
+		return nil
 	}
 
-	entry := scanEntry{tok: tok, lit: lit, pos: Pos(pos)}
-
-	tracef("scanIdent tok=%s; unscanning entry=%+#v", tok, entry)
-
-	unscanBuf = append([]scanEntry{entry}, unscanBuf...)
-
-	for _, entry := range unscanBuf {
-		p.unscan(entry.tok, entry.lit, entry.pos)
-	}
-
-	return "", errors.Wrapf(ErrSyntax, "expected ident at pos=%v but got %s (%q)", pos, tok, lit)
-}
-
-func (p *Parser) scan() (Token, string, Pos) {
-	if len(p.buf) != 0 {
-		entry, buf := p.buf[len(p.buf)-1], p.buf[:len(p.buf)-1]
-		p.buf = buf
-
-		tracef("scan returning buffer entry=%s %+#v", entry.tok, entry)
-		return entry.tok, entry.lit, entry.pos
-	}
-
-	tok, lit, pos := p.s.Scan()
-
-	tracef("scan returning next=%s %+#v", tok, scanEntry{tok: tok, lit: lit, pos: pos})
-
-	return tok, lit, pos
-}
-
-func (p *Parser) unscan(tok Token, lit string, pos Pos) {
-	entry := scanEntry{tok: tok, lit: lit, pos: pos}
-
-	tracef("unscan entry=%s %+#v", tok, entry)
-
-	p.buf = append(p.buf, entry)
+	return &PassthroughArgs{Nodes: nodes}
 }

argh/parser2.go

@@ -1,188 +0,0 @@
-package argh
-
-import (
-	"fmt"
-	"io"
-	"strings"
-)
-
-type parser2 struct {
-	s *Scanner
-
-	commands map[string]struct{}
-
-	errors ScannerErrorList
-
-	tok Token
-	lit string
-	pos Pos
-}
-
-func ParseArgs2(args, commands []string) (*ParseTree, error) {
-	parser := &parser2{}
-	parser.init(
-		strings.NewReader(strings.Join(args, string(nul))),
-		commands,
-	)
-
-	tracef("ParseArgs2 parser=%+#v", parser)
-
-	return parser.parseArgs()
-}
-
-func (p *parser2) init(r io.Reader, commands []string) {
-	p.errors = ScannerErrorList{}
-	commandMap := map[string]struct{}{}
-
-	for _, c := range commands {
-		commandMap[c] = struct{}{}
-	}
-
-	p.s = NewScanner(r, nil)
-	p.commands = commandMap
-
-	p.next()
-}
-
-func (p *parser2) parseArgs() (*ParseTree, error) {
-	if p.errors.Len() != 0 {
-		tracef("parseArgs bailing due to initial error")
-		return nil, p.errors.Err()
-	}
-
-	prog := &Program{
-		Name:   p.lit,
-		Values: map[string]string{},
-		Nodes:  []Node{},
-	}
-	p.next()
-
-	for p.tok != EOL && p.tok != STOP_FLAG {
-		prog.Nodes = append(prog.Nodes, p.parseArg())
-	}
-
-	return &ParseTree{
-		Nodes: []Node{
-			prog, p.parsePassthrough(),
-		},
-	}, nil
-}
-
-func (p *parser2) next() {
-	tracef("parser2.next() <- %v %q %v", p.tok, p.lit, p.pos)
-	defer func() {
-		tracef("parser2.next() -> %v %q %v", p.tok, p.lit, p.pos)
-	}()
-
-	p.tok, p.lit, p.pos = p.s.Scan()
-}
-
-func (p *parser2) parseArg() Node {
-	switch p.tok {
-	case ARG_DELIMITER:
-		p.next()
-		return &ArgDelimiter{}
-	case IDENT:
-		if _, ok := p.commands[p.lit]; ok {
-			return p.parseCommand()
-		}
-		return p.parseIdent()
-	case LONG_FLAG, SHORT_FLAG, COMPOUND_SHORT_FLAG:
-		return p.parseFlag()
-	}
-
-	pos := p.pos
-	lit := p.lit
-	p.advanceArg()
-	return &BadArg{Literal: lit, From: pos, To: p.pos}
-}
-
-func (p *parser2) advanceArg() {
-	for ; p.tok != EOL; p.next() {
-		switch p.tok {
-		case IDENT, LONG_FLAG, SHORT_FLAG, COMPOUND_SHORT_FLAG:
-			return
-		}
-	}
-}
-
-func (p *parser2) parseCommand() Node {
-	node := &Command{Name: p.lit, Values: map[string]string{}, Nodes: []Node{}}
-
-	for i := 0; p.tok != EOL; i++ {
-		p.next()
-
-		if _, ok := p.commands[p.lit]; ok {
-			break
-		}
-
-		switch p.tok {
-		case ARG_DELIMITER:
-			continue
-		case IDENT, STDIN_FLAG:
-			node.Values[fmt.Sprintf("%d", i)] = p.lit
-		case LONG_FLAG, SHORT_FLAG, COMPOUND_SHORT_FLAG:
-			node.Nodes = append(node.Nodes, p.parseFlag())
-		default:
-			break
-		}
-	}
-
-	return node
-}
-
-func (p *parser2) parseIdent() Node {
-	defer p.next()
-
-	node := &Ident{Literal: p.lit}
-	return node
-}
-
-func (p *parser2) parseFlag() Node {
-	defer p.next()
-
-	switch p.tok {
-	case SHORT_FLAG:
-		return p.parseShortFlag()
-	case LONG_FLAG:
-		return p.parseLongFlag()
-	case COMPOUND_SHORT_FLAG:
-		return p.parseCompoundShortFlag()
-	}
-
-	panic(fmt.Sprintf("token %v cannot be parsed as flag", p.tok))
-}
-
-func (p *parser2) parseShortFlag() Node {
-	node := &Flag{Name: string(p.lit[1])}
-	// TODO: moar stuff
-	return node
-}
-
-func (p *parser2) parseLongFlag() Node {
-	node := &Flag{Name: string(p.lit[2:])}
-	// TODO: moar stuff
-	return node
-}
-
-func (p *parser2) parseCompoundShortFlag() Node {
-	flagNodes := []Node{}
-
-	withoutFlagPrefix := p.lit[1:]
-
-	for _, r := range withoutFlagPrefix {
-		flagNodes = append(flagNodes, &Flag{Name: string(r)})
-	}
-
-	return &CompoundShortFlag{Nodes: flagNodes}
-}
-
-func (p *parser2) parsePassthrough() Node {
-	nodes := []Node{}
-
-	for ; p.tok != EOL; p.next() {
-		nodes = append(nodes, &Ident{Literal: p.lit})
-	}
-
-	return &PassthroughArgs{Nodes: nodes}
-}

argh/parser2_test.go

@@ -1,36 +0,0 @@
-package argh_test
-
-import (
-	"testing"
-
-	"git.meatballhat.com/x/box-o-sand/argh"
-	"github.com/davecgh/go-spew/spew"
-)
-
-func TestParser2(t *testing.T) {
-	for _, tc := range []struct {
-		name     string
-		args     []string
-		commands []string
-	}{
-		{
-			name: "basic",
-			args: []string{
-				"pies", "-eat", "--wat", "hello",
-			},
-			commands: []string{
-				"hello",
-			},
-		},
-	} {
-		t.Run(tc.name, func(ct *testing.T) {
-			pt, err := argh.ParseArgs2(tc.args, tc.commands)
-			if err != nil {
-				ct.Logf("err=%+#v", err)
-				return
-			}
-
-			spew.Dump(pt)
-		})
-	}
-}

argh/parser_config.go

@@ -7,31 +7,140 @@ const (
 )
 
 var (
-	DefaultParserConfig = &ParserConfig{
-		Commands:      map[string]CommandConfig{},
-		Flags:         map[string]FlagConfig{},
-		ScannerConfig: DefaultScannerConfig,
-	}
+	POSIXyParserConfig = NewParserConfig(
+		nil,
+		POSIXyScannerConfig,
+	)
 )
 
 type NValue int
 
+func (nv NValue) Contains(i int) bool {
+	tracef("NValue.Contains(%v)", i)
+
+	if i < int(ZeroValue) {
+		return false
+	}
+
+	if nv == OneOrMoreValue || nv == ZeroOrMoreValue {
+		return true
+	}
+
+	return int(nv) > i
+}
+
 type ParserConfig struct {
-	Prog     CommandConfig
-	Commands map[string]CommandConfig
-	Flags    map[string]FlagConfig
+	Prog CommandConfig
 
 	ScannerConfig *ScannerConfig
 }
 
+func NewParserConfig(prog *CommandConfig, sCfg *ScannerConfig) *ParserConfig {
+	if sCfg == nil {
+		sCfg = POSIXyScannerConfig
+	}
+
+	if prog == nil {
+		prog = &CommandConfig{}
+	}
+
+	prog.init()
+
+	pCfg := &ParserConfig{
+		Prog:          *prog,
+		ScannerConfig: sCfg,
+	}
+
+	return pCfg
+}
+
 type CommandConfig struct {
 	NValue     NValue
 	ValueNames []string
-	Flags      map[string]FlagConfig
-	Commands   map[string]CommandConfig
+	Flags      *Flags
+	Commands   *Commands
+}
+
+func (cCfg *CommandConfig) init() {
+	if cCfg.ValueNames == nil {
+		cCfg.ValueNames = []string{}
+	}
+
+	if cCfg.Flags == nil {
+		cCfg.Flags = &Flags{}
+	}
+
+	if cCfg.Commands == nil {
+		cCfg.Commands = &Commands{}
+	}
+}
+
+func (cCfg *CommandConfig) GetCommandConfig(name string) (CommandConfig, bool) {
+	tracef("CommandConfig.GetCommandConfig(%q)", name)
+
+	if cCfg.Commands == nil {
+		cCfg.Commands = &Commands{Map: map[string]CommandConfig{}}
+	}
+
+	return cCfg.Commands.Get(name)
+}
+
+func (cCfg *CommandConfig) GetFlagConfig(name string) (FlagConfig, bool) {
+	tracef("CommandConfig.GetFlagConfig(%q)", name)
+
+	if cCfg.Flags == nil {
+		cCfg.Flags = &Flags{Map: map[string]FlagConfig{}}
+	}
+
+	return cCfg.Flags.Get(name)
 }
 
 type FlagConfig struct {
 	NValue     NValue
+	Persist    bool
 	ValueNames []string
 }
+
+type Flags struct {
+	Parent *Flags
+	Map    map[string]FlagConfig
+
+	Automatic bool
+}
+
+func (fl *Flags) Get(name string) (FlagConfig, bool) {
+	tracef("Flags.Get(%q)", name)
+
+	if fl.Map == nil {
+		fl.Map = map[string]FlagConfig{}
+	}
+
+	flCfg, ok := fl.Map[name]
+	if !ok {
+		if fl.Automatic {
+			return FlagConfig{}, true
+		}
+
+		if fl.Parent != nil {
+			flCfg, ok = fl.Parent.Get(name)
+			return flCfg, ok && flCfg.Persist
+		}
+	}
+
+	return flCfg, ok
+}
+
+type Commands struct {
+	Map map[string]CommandConfig
+}
+
+func (cmd *Commands) Get(name string) (CommandConfig, bool) {
+	tracef("Commands.Get(%q)", name)
+
+	if cmd.Map == nil {
+		cmd.Map = map[string]CommandConfig{}
+	}
+
+	cmdCfg, ok := cmd.Map[name]
+	return cmdCfg, ok
+}

argh/parser_error.go

@@ -0,0 +1,88 @@
+package argh
+
+import (
+	"fmt"
+	"io"
+	"sort"
+)
+
+// ParserError is largely borrowed from go/scanner.Error
+type ParserError struct {
+	Pos Position
+	Msg string
+}
+
+func (e ParserError) Error() string {
+	if e.Pos.IsValid() {
+		return e.Pos.String() + ":" + e.Msg
+	}
+
+	return e.Msg
+}
+
+// ParserErrorList is largely borrowed from go/scanner.ErrorList
+type ParserErrorList []*ParserError
+
+func (el *ParserErrorList) Add(pos Position, msg string) {
+	*el = append(*el, &ParserError{Pos: pos, Msg: msg})
+}
+
+func (el *ParserErrorList) Reset() { *el = (*el)[0:0] }
+
+func (el ParserErrorList) Len() int { return len(el) }
+
+func (el ParserErrorList) Swap(i, j int) { el[i], el[j] = el[j], el[i] }
+
+func (el ParserErrorList) Less(i, j int) bool {
+	e := &el[i].Pos
+	f := &el[j].Pos
+
+	if e.Column != f.Column {
+		return e.Column < f.Column
+	}
+
+	return el[i].Msg < el[j].Msg
+}
+
+func (el ParserErrorList) Sort() {
+	sort.Sort(el)
+}
+
+func (el ParserErrorList) Error() string {
+	switch len(el) {
+	case 0:
+		return "no errors"
+	case 1:
+		return el[0].Error()
+	}
+	return fmt.Sprintf("%s (and %d more errors)", el[0], len(el)-1)
+}
+
+func (el ParserErrorList) Err() error {
+	if len(el) == 0 {
+		return nil
+	}
+	return el
+}
+
+func (el ParserErrorList) Is(other error) bool {
+	if _, ok := other.(ParserErrorList); ok {
+		return el.Error() == other.Error()
+	}
+
+	if v, ok := other.(*ParserErrorList); ok {
+		return el.Error() == (*v).Error()
+	}
+
+	return false
+}
+
+func PrintParserError(w io.Writer, err error) {
+	if list, ok := err.(ParserErrorList); ok {
+		for _, e := range list {
+			fmt.Fprintf(w, "%s\n", e)
+		}
+	} else if err != nil {
+		fmt.Fprintf(w, "%s\n", err)
+	}
+}

argh/querier.go

@@ -1,74 +1,92 @@
 package argh
 
-import "fmt"
-
 type Querier interface {
-	Program() (Program, bool)
-	TypedAST() []TypedNode
+	Program() (*Command, bool)
 	AST() []Node
 }
 
-func NewQuerier(pt *ParseTree) Querier {
-	return &defaultQuerier{pt: pt}
+func NewQuerier(nodes []Node) Querier {
+	return &defaultQuerier{nodes: nodes}
 }
 
 type defaultQuerier struct {
-	pt *ParseTree
+	nodes []Node
 }
 
-func (dq *defaultQuerier) Program() (Program, bool) {
-	if len(dq.pt.Nodes) == 0 {
-		return Program{}, false
+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
 	}
 
-	v, ok := dq.pt.Nodes[0].(Program)
 	return v, ok
 }
 
-func (dq *defaultQuerier) TypedAST() []TypedNode {
-	ret := []TypedNode{}
-
-	for _, node := range dq.pt.Nodes {
-		if _, ok := node.(ArgDelimiter); ok {
-			continue
-		}
-
-		if _, ok := node.(StopFlag); ok {
-			continue
-		}
-
-		ret = append(
-			ret,
-			TypedNode{
-				Type: fmt.Sprintf("%T", node),
-				Node: node,
-			},
-		)
-	}
-
-	return ret
-}
-
 func (dq *defaultQuerier) AST() []Node {
 	ret := []Node{}
 
-	for _, node := range dq.pt.Nodes {
-		if _, ok := node.(ArgDelimiter); ok {
+	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 {
+		if _, ok := node.(*StopFlag); ok {
 			continue
 		}
 
-		if v, ok := node.(CompoundShortFlag); ok {
-			for _, subNode := range v.Nodes {
-				ret = append(ret, subNode)
+		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)
 	}
 

argh/querier_test.go

@@ -12,31 +12,39 @@ func TestQuerier_Program(t *testing.T) {
 		name  string
 		args  []string
 		cfg   *argh.ParserConfig
-		exp   argh.Program
+		exp   string
 		expOK bool
 	}{
 		{
-			name:  "typical",
-			args:  []string{"pizzas", "ahoy", "--treatsa", "fun"},
-			exp:   argh.Program{Name: "pizzas"},
+			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:   argh.Program{Name: "pizzas"},
+			exp:   "pizzas",
 			expOK: true,
 		},
 		{
 			name:  "invalid",
 			args:  []string{},
-			exp:   argh.Program{},
-			expOK: false,
-		},
-		{
-			name:  "invalid flag only",
-			args:  []string{"--oh-no"},
-			exp:   argh.Program{},
 			expOK: false,
 		},
 	} {
@@ -44,9 +52,9 @@ func TestQuerier_Program(t *testing.T) {
 			pt, err := argh.ParseArgs(tc.args, tc.cfg)
 			require.Nil(ct, err)
 
-			prog, ok := argh.NewQuerier(pt).Program()
-			require.Equal(ct, tc.exp, prog)
+			prog, ok := argh.NewQuerier(pt.Nodes).Program()
 			require.Equal(ct, tc.expOK, ok)
+			require.Equal(ct, tc.exp, prog.Name)
 		})
 	}
 }

argh/scanner.go

@@ -4,109 +4,20 @@ import (
 	"bufio"
 	"bytes"
 	"errors"
-	"fmt"
 	"io"
 	"log"
-	"sort"
 	"unicode"
 )
 
-const (
-	nul = rune(0)
-	eol = rune(-1)
-)
-
-var (
-	DefaultScannerConfig = &ScannerConfig{
-		AssignmentOperator: '=',
-		FlagPrefix:         '-',
-		MultiValueDelim:    ',',
-	}
-)
-
 type Scanner struct {
 	r   *bufio.Reader
 	i   int
 	cfg *ScannerConfig
 }
 
-type ScannerConfig struct {
-	AssignmentOperator rune
-	FlagPrefix         rune
-	MultiValueDelim    rune
-}
-
-// ScannerError is largely borrowed from go/scanner.Error
-type ScannerError struct {
-	Pos Position
-	Msg string
-}
-
-func (e ScannerError) Error() string {
-	if e.Pos.IsValid() {
-		return e.Pos.String() + ":" + e.Msg
-	}
-	return e.Msg
-}
-
-// ScannerErrorList is largely borrowed from go/scanner.ErrorList
-type ScannerErrorList []*ScannerError
-
-func (el *ScannerErrorList) Add(pos Position, msg string) {
-	*el = append(*el, &ScannerError{Pos: pos, Msg: msg})
-}
-
-func (el *ScannerErrorList) Reset() { *el = (*el)[0:0] }
-
-func (el ScannerErrorList) Len() int { return len(el) }
-
-func (el ScannerErrorList) Swap(i, j int) { el[i], el[j] = el[j], el[i] }
-
-func (el ScannerErrorList) Less(i, j int) bool {
-	e := &el[i].Pos
-	f := &el[j].Pos
-
-	if e.Column != f.Column {
-		return e.Column < f.Column
-	}
-
-	return el[i].Msg < el[j].Msg
-}
-
-func (el ScannerErrorList) Sort() {
-	sort.Sort(el)
-}
-
-func (el ScannerErrorList) Error() string {
-	switch len(el) {
-	case 0:
-		return "no errors"
-	case 1:
-		return el[0].Error()
-	}
-	return fmt.Sprintf("%s (and %d more errors)", el[0], len(el)-1)
-}
-
-func (el ScannerErrorList) Err() error {
-	if len(el) == 0 {
-		return nil
-	}
-	return el
-}
-
-func PrintScannerError(w io.Writer, err error) {
-	if list, ok := err.(ScannerErrorList); ok {
-		for _, e := range list {
-			fmt.Fprintf(w, "%s\n", e)
-		}
-	} else if err != nil {
-		fmt.Fprintf(w, "%s\n", err)
-	}
-}
-
 func NewScanner(r io.Reader, cfg *ScannerConfig) *Scanner {
 	if cfg == nil {
-		cfg = DefaultScannerConfig
+		cfg = POSIXyScannerConfig
 	}
 
 	return &Scanner{
@@ -118,16 +29,16 @@ func NewScanner(r io.Reader, cfg *ScannerConfig) *Scanner {
 func (s *Scanner) Scan() (Token, string, Pos) {
 	ch, pos := s.read()
 
-	if s.isBlankspace(ch) {
+	if s.cfg.IsBlankspace(ch) {
 		_ = s.unread()
 		return s.scanBlankspace()
 	}
 
-	if s.isAssignmentOperator(ch) {
+	if s.cfg.IsAssignmentOperator(ch) {
 		return ASSIGN, string(ch), pos
 	}
 
-	if s.isMultiValueDelim(ch) {
+	if s.cfg.IsMultiValueDelim(ch) {
 		return MULTI_VALUE_DELIMITER, string(ch), pos
 	}
 
@@ -167,26 +78,6 @@ func (s *Scanner) unread() Pos {
 	return Pos(s.i)
 }
 
-func (s *Scanner) isBlankspace(ch rune) bool {
-	return ch == ' ' || ch == '\t' || ch == '\n'
-}
-
-func (s *Scanner) isUnderscore(ch rune) bool {
-	return ch == '_'
-}
-
-func (s *Scanner) isFlagPrefix(ch rune) bool {
-	return ch == s.cfg.FlagPrefix
-}
-
-func (s *Scanner) isMultiValueDelim(ch rune) bool {
-	return ch == s.cfg.MultiValueDelim
-}
-
-func (s *Scanner) isAssignmentOperator(ch rune) bool {
-	return ch == s.cfg.AssignmentOperator
-}
-
 func (s *Scanner) scanBlankspace() (Token, string, Pos) {
 	buf := &bytes.Buffer{}
 	ch, pos := s.read()
@@ -197,7 +88,7 @@ func (s *Scanner) scanBlankspace() (Token, string, Pos) {
 
 		if ch == eol {
 			break
-		} else if !s.isBlankspace(ch) {
+		} else if !s.cfg.IsBlankspace(ch) {
 			pos = s.unread()
 			break
 		} else {
@@ -216,7 +107,7 @@ func (s *Scanner) scanArg() (Token, string, Pos) {
 	for {
 		ch, pos = s.read()
 
-		if ch == eol || ch == nul || s.isAssignmentOperator(ch) || s.isMultiValueDelim(ch) {
+		if ch == eol || ch == nul || s.cfg.IsAssignmentOperator(ch) || s.cfg.IsMultiValueDelim(ch) {
 			pos = s.unread()
 			break
 		}
@@ -233,11 +124,11 @@ func (s *Scanner) scanArg() (Token, string, Pos) {
 	ch0 := rune(str[0])
 
 	if len(str) == 1 {
-		if s.isFlagPrefix(ch0) {
+		if s.cfg.IsFlagPrefix(ch0) {
 			return STDIN_FLAG, str, pos
 		}
 
-		if s.isAssignmentOperator(ch0) {
+		if s.cfg.IsAssignmentOperator(ch0) {
 			return ASSIGN, str, pos
 		}
 
@@ -247,17 +138,17 @@ func (s *Scanner) scanArg() (Token, string, Pos) {
 	ch1 := rune(str[1])
 
 	if len(str) == 2 {
-		if str == string(s.cfg.FlagPrefix)+string(s.cfg.FlagPrefix) {
+		if s.cfg.IsFlagPrefix(ch0) && s.cfg.IsFlagPrefix(ch1) {
 			return STOP_FLAG, str, pos
 		}
 
-		if s.isFlagPrefix(ch0) {
+		if s.cfg.IsFlagPrefix(ch0) {
 			return SHORT_FLAG, str, pos
 		}
 	}
 
-	if s.isFlagPrefix(ch0) {
-		if s.isFlagPrefix(ch1) {
+	if s.cfg.IsFlagPrefix(ch0) {
+		if s.cfg.IsFlagPrefix(ch1) {
 			return LONG_FLAG, str, pos
 		}
 

argh/scanner_config.go

@@ -0,0 +1,39 @@
+package argh
+
+var (
+	// POSIXyScannerConfig defines a scanner config that uses '-'
+	// as the flag prefix, which also means that "--" is the "long
+	// flag" prefix, a bare "--" is considered STOP_FLAG, and a
+	// bare "-" is considered STDIN_FLAG.
+	POSIXyScannerConfig = &ScannerConfig{
+		AssignmentOperator: '=',
+		FlagPrefix:         '-',
+		MultiValueDelim:    ',',
+	}
+)
+
+type ScannerConfig struct {
+	AssignmentOperator rune
+	FlagPrefix         rune
+	MultiValueDelim    rune
+}
+
+func (cfg *ScannerConfig) IsFlagPrefix(ch rune) bool {
+	return ch == cfg.FlagPrefix
+}
+
+func (cfg *ScannerConfig) IsMultiValueDelim(ch rune) bool {
+	return ch == cfg.MultiValueDelim
+}
+
+func (cfg *ScannerConfig) IsAssignmentOperator(ch rune) bool {
+	return ch == cfg.AssignmentOperator
+}
+
+func (cfg *ScannerConfig) IsBlankspace(ch rune) bool {
+	return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'
+}
+
+func (cfg *ScannerConfig) IsUnderscore(ch rune) bool {
+	return ch == '_'
+}

argh/token.go

@@ -18,6 +18,9 @@ const (
 	COMPOUND_SHORT_FLAG   // char group with single flag prefix: '-flag'
 	STDIN_FLAG            // '-'
 	STOP_FLAG             // '--'
+
+	nul = rune(0)
+	eol = rune(-1)
 )
 
 type Token int