feat: upgrade goNixArgParser

Author: marjune163

src/goNixArgParser/arg.go

@@ -2,27 +2,27 @@ package goNixArgParser
 
 import (
 	"bytes"
-	"os"
+	"io"
 	"path"
 )
 
 func NewCommand(
 	names []string,
 	summary, mergeFlagPrefix string,
-	restsSigns, groupSeps, undefFlagPrefixes []string,
+	restsSigns, groupSeps, assignSigns, undefFlagPrefixes []string,
 ) *Command {
 	return &Command{
 		names:       names,
 		summary:     summary,
-		options:     NewOptionSet(mergeFlagPrefix, restsSigns, groupSeps, undefFlagPrefixes),
+		options:     NewOptionSet(mergeFlagPrefix, restsSigns, groupSeps, assignSigns, undefFlagPrefixes),
 		subCommands: []*Command{},
 	}
 }
 
 func NewSimpleCommand(name, summary string, aliasNames ...string) *Command {
-	names := make([]string, 0, 1+len(aliasNames))
-	names = append(names, name)
-	names = append(names, aliasNames...)
+	names := make([]string, 1+len(aliasNames))
+	names[0] = name
+	copy(names[1:], aliasNames)
 
 	return &Command{
 		names:       names,
@@ -35,9 +35,9 @@ func NewSimpleCommand(name, summary string, aliasNames ...string) *Command {
 func (c *Command) NewSubCommand(
 	names []string,
 	summary, mergeFlagPrefix string,
-	restsSigns, groupSeps, undefFlagPrefixes []string,
+	restsSigns, groupSeps, assignSigns, undefFlagPrefixes []string,
 ) *Command {
-	subCommand := NewCommand(names, summary, mergeFlagPrefix, restsSigns, groupSeps, undefFlagPrefixes)
+	subCommand := NewCommand(names, summary, mergeFlagPrefix, restsSigns, groupSeps, assignSigns, undefFlagPrefixes)
 	c.subCommands = append(c.subCommands, subCommand)
 	return subCommand
 }
@@ -58,10 +58,6 @@ func (c *Command) hasName(name string) bool {
 }
 
 func (c *Command) GetSubCommand(name string) *Command {
-	if c.subCommands == nil {
-		return nil
-	}
-
 	for _, cmd := range c.subCommands {
 		if cmd.hasName(name) {
 			return cmd
@@ -79,7 +75,9 @@ func (c *Command) Name() (name string) {
 }
 
 func (c *Command) Names() []string {
-	return c.names
+	names := make([]string, len(c.names))
+	copy(names, c.names)
+	return names
 }
 
 func (c *Command) Summary() string {
@@ -94,116 +92,107 @@ func (c *Command) SubCommands() []*Command {
 	return c.subCommands
 }
 
-func (c *Command) getNormalizedArgs(initArgs []string) (*Command, []*Arg) {
-	cmd := c
+func (c *Command) getLeafCmd(args []string) (explicitCmd *Command, inferredCmd *Command, cmdPaths []string) {
+	inferredCmd = c
 
-	if len(initArgs) == 0 {
-		return cmd, []*Arg{}
+	if len(args) == 0 {
+		return explicitCmd, inferredCmd, []string{}
 	}
 
-	args := make([]*Arg, 0, len(initArgs))
-
-	for i, arg := range initArgs {
-		if i == 0 && cmd.hasName(arg) {
-			args = append(args, NewArg(cmd.Name(), CommandArg))
-		} else if subCmd := cmd.GetSubCommand(arg); subCmd != nil {
-			args = append(args, NewArg(subCmd.Name(), CommandArg))
-			cmd = subCmd
+	for i, arg := range args {
+		if i == 0 && inferredCmd.hasName(arg) {
+			explicitCmd = c
+			cmdPaths = append(cmdPaths, inferredCmd.Name())
+		} else if subCmd := inferredCmd.GetSubCommand(arg); subCmd != nil {
+			explicitCmd = subCmd
+			inferredCmd = subCmd
+			cmdPaths = append(cmdPaths, inferredCmd.Name())
 		} else {
 			break
 		}
 	}
 
-	return cmd, args
+	return
 }
 
-func (c *Command) splitCommandsArgs(initArgs, initConfigs []string) (
-	argsLeafCmd *Command,
-	commands, optionSetInitArgs, optionSetInitConfigs []string,
+func (c *Command) extractCmdOptionArgs(specifiedArgs, configArgs []string) (
+	specifiedCmd *Command,
+	cmdPaths, specifiedOptionArgs, configOptionArgs []string,
 ) {
-	argsLeafCmd, argCmds := c.getNormalizedArgs(initArgs)
-	configsLeafCmd, configCmds := c.getNormalizedArgs(initConfigs)
+	_, specifiedCmd, specifiedCmdPaths := c.getLeafCmd(specifiedArgs)
+	explicitConfigCmd, configCmd, configCmdPaths := c.getLeafCmd(configArgs)
 
-	commands = []string{}
-	for _, arg := range argCmds {
-		commands = append(commands, arg.Text)
-	}
+	cmdPaths = specifiedCmdPaths
 
-	optionSetInitArgs = initArgs[len(argCmds):]
+	specifiedOptionArgs = specifiedArgs[len(specifiedCmdPaths):]
 
-	if argsLeafCmd == configsLeafCmd {
-		optionSetInitConfigs = initConfigs[len(configCmds):]
+	if specifiedCmd == configCmd {
+		configOptionArgs = configArgs[len(configCmdPaths):]
+	} else if explicitConfigCmd == nil {
+		configOptionArgs = configArgs
 	} else {
-		optionSetInitConfigs = []string{}
+		configOptionArgs = []string{}
 	}
 
 	return
 }
 
-func (c *Command) Parse(initArgs, initConfigs []string) *ParseResult {
-	leafCmd, commands, optionSetInitArgs, optionSetInitConfigs := c.splitCommandsArgs(initArgs, initConfigs)
-	result := leafCmd.options.Parse(optionSetInitArgs, optionSetInitConfigs)
-	result.commands = commands
+func (c *Command) Parse(specifiedArgs, configArgs []string) *ParseResult {
+	cmd, cmdPaths, specifiedOptionArgs, configOptionArgs := c.extractCmdOptionArgs(specifiedArgs, configArgs)
+	result := cmd.options.Parse(specifiedOptionArgs, configOptionArgs)
+	result.commands = cmdPaths
 
 	return result
 }
 
-func (c *Command) ParseGroups(initArgs, initConfigs []string) (results []*ParseResult) {
-	leafCmd, commands, optionSetInitArgs, optionSetInitConfigs := c.splitCommandsArgs(initArgs, initConfigs)
+func (c *Command) ParseGroups(specifiedArgs, configArgs []string) (results []*ParseResult) {
+	cmd, cmdPaths, specifiedOptionArgs, configOptionArgs := c.extractCmdOptionArgs(specifiedArgs, configArgs)
 
-	if len(optionSetInitArgs) == 0 && len(optionSetInitConfigs) == 0 {
-		result := leafCmd.options.Parse(optionSetInitArgs, optionSetInitConfigs)
+	if len(specifiedOptionArgs) == 0 && len(configOptionArgs) == 0 {
+		result := cmd.options.Parse(specifiedOptionArgs, configOptionArgs)
 		results = append(results, result)
 	} else {
-		results = leafCmd.options.ParseGroups(optionSetInitArgs, optionSetInitConfigs)
+		results = cmd.options.ParseGroups(specifiedOptionArgs, configOptionArgs)
 	}
 
 	for _, result := range results {
-		result.commands = commands
+		result.commands = cmdPaths
 	}
 
 	return results
 }
 
-func (c *Command) GetHelp() []byte {
+func (c *Command) OutputHelp(w io.Writer) {
+	newline := []byte{'\n'}
 	buffer := &bytes.Buffer{}
 
 	name := c.Name()
 	if len(name) > 0 {
-		buffer.WriteString(path.Base(name))
-		buffer.WriteString(": ")
+		io.WriteString(w, path.Base(name))
+		io.WriteString(w, ": ")
 	}
 	if len(c.summary) > 0 {
-		buffer.WriteString(c.summary)
+		io.WriteString(w, c.summary)
 	}
 	if buffer.Len() > 0 {
 		buffer.WriteByte('\n')
 	} else {
-		buffer.WriteString("Usage:\n")
+		io.WriteString(w, "Usage:\n")
 	}
 
-	optionsHelp := c.options.GetHelp()
-	if len(optionsHelp) > 0 {
-		buffer.WriteString("\nOptions:\n\n")
-		buffer.Write(optionsHelp)
-	}
+	io.WriteString(w, "\nOptions:\n\n")
+	c.options.OutputHelp(w)
 
 	if len(c.subCommands) > 0 {
-		buffer.WriteString("\nSub commands:\n\n")
+		io.WriteString(w, "\nSub commands:\n\n")
 		for _, cmd := range c.subCommands {
-			buffer.WriteString(cmd.Name())
-			buffer.WriteByte('\n')
+			io.WriteString(w, cmd.Name())
+			w.Write(newline)
 			if len(cmd.summary) > 0 {
-				buffer.WriteString(cmd.summary)
-				buffer.WriteByte('\n')
+				io.WriteString(w, cmd.summary)
+				w.Write(newline)
 			}
-			buffer.WriteByte('\n')
+			w.Write(newline)
 		}
 	}
-
-	return buffer.Bytes()
-}
-
-func (c *Command) PrintHelp() {
-	os.Stdout.Write(c.GetHelp())
 }

src/goNixArgParser/command.go

@@ -1,7 +1,6 @@
 package goNixArgParser
 
 import (
-	"fmt"
 	"testing"
 )
 
@@ -25,14 +24,16 @@ func getGitCommand() *Command {
 	return cmdGit
 }
 
-func TestNormalizeCmdArgs(t *testing.T) {
+/*
+func TestGetLeafCmd(t *testing.T) {
 	cmd := getGitCommand()
 	args := []string{"git", "rmt", "set-url", "--push", "origin", "https://github.com/mjpclab/goNixArgParser.git"}
-	_, normalizedArgs := cmd.getNormalizedArgs(args)
+	_, normalizedArgs := cmd.getLeafCmd(args)
 	for i, arg := range normalizedArgs {
 		fmt.Printf("%d %+v\n", i, arg)
 	}
 }
+*/
 
 func TestParseCommand1(t *testing.T) {
 	cmd := getGitCommand()
@@ -49,12 +50,10 @@ func TestParseCommand1(t *testing.T) {
 		t.Error("push")
 	}
 
-	if result.argRests[0] != "origin" ||
-		result.argRests[1] != "https://github.com/mjpclab/goNixArgParser.git" {
-		t.Error("rests", result.argRests)
+	if result.specifiedRests[0] != "origin" ||
+		result.specifiedRests[1] != "https://github.com/mjpclab/goNixArgParser.git" {
+		t.Error("rests", result.specifiedRests)
 	}
-
-	cmd.PrintHelp()
 }
 
 func TestParseCommand2(t *testing.T) {
@@ -67,11 +66,11 @@ func TestParseCommand2(t *testing.T) {
 		t.Error("commands", result.commands)
 	}
 
-	if result.argRests[0] != "xxx" ||
-		result.argRests[1] != "set-url" ||
-		result.argRests[2] != "origin" ||
-		result.argRests[3] != "https://github.com/mjpclab/goNixArgParser.git" {
-		t.Error("rests", result.argRests)
+	if result.specifiedRests[0] != "xxx" ||
+		result.specifiedRests[1] != "set-url" ||
+		result.specifiedRests[2] != "origin" ||
+		result.specifiedRests[3] != "https://github.com/mjpclab/goNixArgParser.git" {
+		t.Error("rests", result.specifiedRests)
 	}
 }
 
@@ -83,17 +82,15 @@ func TestParseCommand3(t *testing.T) {
 
 	dummy, _ := result.GetString("dummy")
 	if dummy != "dummyconfigvalue" {
-		fmt.Println("dummy:", dummy)
-		t.Error("dummy config value error")
+		t.Error("dummy config value error", dummy)
 	}
 
 	configArgs = configArgs[1:]
 	result = cmd.Parse(args, configArgs)
 
 	dummy, _ = result.GetString("dummy")
 	if dummy != "dummyconfigvalue" {
-		fmt.Println("dummy:", dummy)
-		t.Error("dummy config value error")
+		t.Error("dummy config value error", dummy)
 	}
 }
 
@@ -160,3 +157,30 @@ func TestParseCommand6(t *testing.T) {
 		t.Error(results[1].GetStrings("dummy"))
 	}
 }
+
+func TestParseCommand7(t *testing.T) {
+	cmd := getGitCommand()
+	args := []string{"git", "remote", "set-url", "github", "https://github.com/mjpclab/goNixArgParser.git"}
+	configArgs := []string{"--dummy", "dummy0"}
+
+	result := cmd.Parse(args, configArgs)
+
+	cmdPaths := result.GetCommands()
+	if len(cmdPaths) != 3 {
+		t.Error(len(cmdPaths))
+	}
+	if cmdPaths[0] != "git" {
+		t.Error(cmdPaths[0])
+	}
+	if cmdPaths[1] != "remote" {
+		t.Error(cmdPaths[1])
+	}
+	if cmdPaths[2] != "set-url" {
+		t.Error(cmdPaths[2])
+	}
+
+	dummy, _ := result.GetString("dummy")
+	if dummy != "dummy0" {
+		t.Error(dummy)
+	}
+}

src/goNixArgParser/commandParse_test.go

@@ -1,13 +1,12 @@
 package goNixArgParser
 
-func NewFlag(name string, prefixMatchLen int, canMerge, canFollowAssign, canConcatAssign bool, assignSigns []string) *Flag {
+func NewFlag(name string, prefixMatchLen int, canMerge, canFollowAssign, canConcatAssign bool) *Flag {
 	return &Flag{
 		Name:            name,
 		prefixMatchLen:  prefixMatchLen,
 		canMerge:        canMerge,
 		canFollowAssign: canFollowAssign,
 		canConcatAssign: canConcatAssign,
-		assignSigns:     assignSigns,
 	}
 }
 
@@ -17,12 +16,7 @@ func NewSimpleFlag(name string) *Flag {
 	canMerge := isSingleChar
 	canConcatAssign := isSingleChar
 
-	assignSigns := make([]string, 0, 1)
-	if !isSingleChar {
-		assignSigns = append(assignSigns, "=")
-	}
-
-	return NewFlag(name, 0, canMerge, true, canConcatAssign, assignSigns)
+	return NewFlag(name, 0, canMerge, true, canConcatAssign)
 }
 
 func NewSimpleFlags(names []string) []*Flag {