CHANGELOG.md

 
+<a name="v1.13.1"></a>
+## [v1.13.1] - 2022-12-23
+
 <a name="v1.13.0"></a>
 ## [v1.13.0] - 2022-10-23
 ### Add Features
@@ -150,6 +153,7 @@
 <a name="v1.0.0"></a>
 ## v1.0.0 - 2022-10-04
 
+[v1.13.1]: https://gitlab.schukai.com/oss/libraries/go/application/xflags/compare/v1.13.0...v1.13.1
 [v1.13.0]: https://gitlab.schukai.com/oss/libraries/go/application/xflags/compare/v1.12.0...v1.13.0
 [v1.12.0]: https://gitlab.schukai.com/oss/libraries/go/application/xflags/compare/v1.11.0...v1.12.0
 [v1.11.0]: https://gitlab.schukai.com/oss/libraries/go/application/xflags/compare/v1.10.2...v1.11.0

README.md

@@ -15,7 +15,7 @@ It supports:
 ## Installation
 
 ```shell
-go get gitlab.schukai.com/oss/libraries/go/network/xflags
+go get gitlab.schukai.com/oss/libraries/go/application/xflags
 ```
 
 **Note:** This library uses [Go Modules](https://github.com/golang/go/wiki/Modules) to manage dependencies.
@@ -33,7 +33,7 @@ package main
 import (
 	"fmt"
 	"os"
-	"gitlab.schukai.com/oss/libraries/go/network/xflags"
+	"gitlab.schukai.com/oss/libraries/go/application/xflags"
 )
 
 ```

command.go

@@ -122,6 +122,21 @@ func (c *cmd[C]) initFlags(x reflect.Value, m map[string]string) {
 		if m[tagLong] != "" {
 			c.flagSet.String(m[tagLong], x.String(), m[tagDescription])
 		}
+	case reflect.Slice:
+
+		if x.Type() == reflect.TypeOf(StringFlags{}) {
+
+			if m[tagShort] != "" {
+				xx := x.Interface().(StringFlags)
+				c.flagSet.Var(&xx, m[tagShort], m[tagDescription])
+			}
+
+			if m[tagLong] != "" {
+				xx := x.Interface().(StringFlags)
+				c.flagSet.Var(&xx, m[tagLong], m[tagDescription])
+			}
+
+		}
 
 	default:
 		c.settings.errors = append(c.settings.errors, newUnsupportedFlagTypeError(x.Type()))
@@ -163,7 +178,6 @@ func (c *cmd[C]) parseStruct(dta any) {
 			}
 			c.initFlags(x, m)
 		} else if m[tagCommand] != "" {
-			//c.tagMapping["cmd"+m[tagCommand]] = v.Type().Field(i).Name
 
 			c.initCommands(x, m, v.Type().Field(i).Name)
 		} else if m[tagIgnore] != "" {

error.go

@@ -20,19 +20,16 @@ func (s *Settings[C]) HasErrors() bool {
 	return len(s.errors) > 0
 }
 
-func (s *Settings[C]) HasHint() bool {
-	return s.hint != ""
-}
-
-func (s *Settings[C]) GetHint() string {
-	return s.hint
-}
-
 // Get all errors
 func (s *Settings[C]) Errors() []error {
 	return s.errors
 }
 
+func (s *Settings[C]) AddError(err error) *Settings[C] {
+	s.errors = append(s.errors, err)
+	return s
+}
+
 var WatchListNotInitializedError = errors.New("watch list not initialized")
 var MissingCommandError = errors.New("missing command")
 var NotParsedError = errors.New("flag set not parsed")

execute.go

@@ -6,10 +6,8 @@ package xflags
 import (
 	"flag"
 	"fmt"
-	"github.com/stretchr/testify/assert"
 	"reflect"
 	"strings"
-	"testing"
 )
 
 func (s *Settings[C]) Execute() *Settings[C] {
@@ -118,33 +116,3 @@ func (s *Settings[C]) MissingCommand() bool {
 func (s *Settings[C]) WasExecuted() bool {
 	return s.wasExecuted
 }
-
-func TestWrongDefinitionType(t *testing.T) {
-	c := New("root", 2)
-	c.Parse([]string{"test"})
-	c.Execute()
-	assert.True(t, c.HasErrors())
-}
-
-type testExecuteCommandStruct struct {
-	Command1 struct {
-	} `command:"command1" description:"Command 1" callback:"command1Callback" `
-	Command2 struct {
-		Command3 struct {
-		} `command:"command3" description:"Command 3" callback:"command3Callback" call:"DoCmd3"`
-	} `command:"command2" description:"Command 2" callback:"command2Callback" `
-}
-
-func (c *testExecuteCommandStruct) DoCmd3(s *Settings[testExecuteCommandStruct]) {
-}
-
-func (c *testExecuteCommandStruct) command1Callback(args []string) {
-	fmt.Println("command1Callback", args)
-}
-
-func TestExecute1(t *testing.T) {
-	c := New("root", testExecuteCommandStruct{})
-	c.Parse([]string{"command2", "command3", "commandX"})
-	c.Execute()
-	assert.False(t, c.HasErrors())
-}

execute_test.go

@@ -4,11 +4,42 @@
 package xflags
 
 import (
+	"fmt"
 	"github.com/stretchr/testify/assert"
 	"strconv"
 	"testing"
 )
 
+func TestWrongDefinitionType(t *testing.T) {
+	c := New("root", 2)
+	c.Parse([]string{"test"})
+	c.Execute()
+	assert.True(t, c.HasErrors())
+}
+
+type testExecuteCommandStruct struct {
+	Command1 struct {
+	} `command:"command1" description:"Command 1" callback:"command1Callback" `
+	Command2 struct {
+		Command3 struct {
+		} `command:"command3" description:"Command 3" callback:"command3Callback" call:"DoCmd3"`
+	} `command:"command2" description:"Command 2" callback:"command2Callback" `
+}
+
+func (c *testExecuteCommandStruct) DoCmd3(s *Settings[testExecuteCommandStruct]) {
+}
+
+func (c *testExecuteCommandStruct) command1Callback(args []string) {
+	fmt.Println("command1Callback", args)
+}
+
+func TestExecute1(t *testing.T) {
+	c := New("root", testExecuteCommandStruct{})
+	c.Parse([]string{"command2", "command3", "commandX"})
+	c.Execute()
+	assert.False(t, c.HasErrors())
+}
+
 type testExecutionStruct struct {
 	callbackCounter int `ignore:"true"`
 

help-util.go

@@ -96,7 +96,7 @@ func getFlagTable(f *flag.FlagSet) []string {
 // isZeroValue determines whether the string represents the zero
 // value for a flag.
 func isZeroValue(f *flag.Flag, value string) (ok bool, err error) {
-	// Build a zero value of the flag's Value type, and see if the
+	// Sync a zero value of the flag's Value type, and see if the
 	// result of calling its String method equals the value passed in.
 	// This works unless the Value type is itself an interface type.
 	typ := reflect.TypeOf(f.Value)

help.go

@@ -27,10 +27,11 @@ func (c *cmd[C]) getCommandLevel() (*cmd[C], []string) {
 	return result, path
 }
 
-// Help returns the help text for the command
 func (s *Settings[C]) Help() string {
+	return s.createHelp(s.command, []string{})
+}
 
-	cmd, path := s.command.getCommandLevel()
+func (s *Settings[C]) createHelp(cmd *cmd[C], path []string) string {
 
 	h := strings.Join(path, " ")
 	var help string
@@ -67,6 +68,12 @@ func (s *Settings[C]) Help() string {
 
 		}
 	}
-
 	return help
 }
+
+// Help returns the help text for the command
+func (s *Settings[C]) ContextHelp() string {
+	cmd, path := s.command.getCommandLevel()
+	return s.createHelp(cmd, path)
+
+}

help_test.go

@@ -32,9 +32,9 @@ func TestGetHelp(t *testing.T) {
 		args      []string
 		substring string
 	}{
-		{"test1", []string{"sub1", "--help"}, "Usage: test1 sub1 [global options] [command] [arguments]"},
-		{"test1", []string{"xsd", "help"}, "Usage: test1 [global options] [command] [arguments]"},
-		{"test2", []string{"sub1", "sub2"}, "Usage: test2 sub1 sub2 [global options] [command] [arguments]"},
+		{"test1", []string{"sub1", "--help"}, "Usage:  [global options] [command] [arguments]\n\nGlobal Options:\n  -a\tMessage A\n  -x int\n    \tMessage X\n\nCommand: sub1\n\nOptions:\n  -b\tMessage B\n"},
+		{"test1", []string{"xsd", "help"}, "Usage:  [global options] [command] [arguments]\n\nGlobal Options:\n  -a\tMessage A\n  -x int\n    \tMessage X\n\nCommand: sub1\n\nOptions:\n  -b\tMessage B\n"},
+		{"test2", []string{"sub1", "sub2"}, "Usage:  [global options] [command] [arguments]\n\nGlobal Options:\n  -a\tMessage A\n  -x int\n    \tMessage X\n\nCommand: sub1\n\nOptions:\n  -b\tMessage B\n"},
 	}
 
 	for _, table := range tables {

hint.go

+package xflags
+
+func (s *Settings[C]) SetHint(hint string) *Settings[C] {
+	s.hint = hint
+	return s
+}
+
+func (s *Settings[C]) HasHint() bool {
+	return s.hint != ""
+}
+
+func (s *Settings[C]) GetHint() string {
+	return s.hint
+}

mapping.go

@@ -48,7 +48,18 @@ func (s *Settings[C]) assignValues(c cmd[C]) {
 		pa := append(c.valuePath, k)
 		p := strings.Join(pa, ".")
 
-		err := pathfinder.SetValue(&s.definitions, p, value)
+		q, err := pathfinder.GetValue(&s.definitions, p)
+		if err != nil {
+			s.errors = append(s.errors, err)
+			return
+		}
+
+		if q == nil {
+			q = reflect.New(reflect.TypeOf(q).Elem()).Interface()
+		}
+
+		err = pathfinder.SetValue(&s.definitions, p, value)
+
 		if err != nil {
 			s.errors = append(s.errors, err)
 		}

release.json

-{"version":"1.13.0"}
+{"version":"1.13.1"}

type.go

+package xflags
+
+import (
+	"fmt"
+	"strings"
+)
+
+type StringFlags []string
+
+func (i *StringFlags) String() string {
+	return strings.Join(*i, ",")
+}
+
+func (i *StringFlags) Set(value string) error {
+	*i = append(*i, value)
+	return nil
+}
+
+type IntFlags []int
+
+func (i *IntFlags) String() string {
+	r := make([]string, len(*i))
+	for k, v := range *i {
+		r[k] = fmt.Sprintf("%c", v)
+	}
+
+	return strings.Join(r, ",")
+}
+
+func (i *IntFlags) Set(value int) error {
+	*i = append(*i, value)
+	return nil
+}