✨ feat: gflag - add new method FuncOpt() for quick add a func option flag

Author: inhere

app.go

@@ -505,6 +505,11 @@ func (app *App) Run(args []string) (code int) {
 	return app.exitOnEnd(exCode)
 }
 
+// RunArgs running a command with custom args
+func (app *App) RunArgs(args ...string) int {
+	return app.Run(args)
+}
+
 // RunLine manual run a command by command line string.
 //
 // eg: app.RunLine("top --top-opt val0 sub --sub-opt val1 arg0")

base.go

@@ -241,12 +241,12 @@ func (b *base) ResetData() {
 	}
 }
 
-// GetCommand get a command by name
+// GetCommand get a command by top name
 func (b *base) GetCommand(name string) *Command {
 	return b.commands[name]
 }
 
-// Command get a command by name
+// Command get a command by top name
 func (b *base) Command(name string) (c *Command, exist bool) {
 	c, exist = b.commands[name]
 	return
@@ -272,13 +272,13 @@ func (b *base) HasCommands() bool {
 	return len(b.cmdNames) > 0
 }
 
-// HasCommand name check
+// HasCommand top command name check
 func (b *base) HasCommand(name string) bool {
 	_, has := b.cmdNames[name]
 	return has
 }
 
-// IsCommand name check. alias of the HasCommand()
+// IsCommand top command name check. alias of the HasCommand()
 func (b *base) IsCommand(name string) bool {
 	_, has := b.cmdNames[name]
 	return has
@@ -322,7 +322,7 @@ func (b *base) addCommand(pName string, c *Command) {
 	b.commands[cName] = c
 }
 
-// Match command by path names. eg. ["top", "sub"]
+// Match command by path names. eg: ["top", "sub"]
 func (b *base) Match(names []string) *Command {
 	ln := len(names)
 	if ln == 0 {
@@ -351,7 +351,7 @@ func (b *base) FindCommand(path string) *Command {
 	return b.Match(splitPath2names(path))
 }
 
-// FindByPath command by path. eg. "top:sub" or "top sub"
+// FindByPath command by path. eg: "top:sub" or "top sub"
 func (b *base) FindByPath(path string) *Command {
 	return b.Match(splitPath2names(path))
 }

gflag/gflag_test.go

@@ -193,6 +193,20 @@ func TestFlags_Uint64Opt(t *testing.T) {
 	assert.Eq(t, uint64(16), uint2)
 }
 
+func TestFlags_FuncOpt(t *testing.T) {
+	fs := gcli.NewFlags("testFlags")
+
+	var str string
+	fs.FuncOpt("str, s", "desc", func(v string) error {
+		str = v
+		return nil
+	})
+
+	assert.Eq(t, "", str)
+	assert.NoErr(t, fs.Parse([]string{"-s", "abc"}))
+	assert.Eq(t, "abc", str)
+}
+
 func TestFlags_VarOpt(t *testing.T) {
 	fs := gcli.NewFlags("testFlags")
 
@@ -441,6 +455,34 @@ func TestFlags_FromStruct_noNameStruct(t *testing.T) {
 	assert.True(t, fs.IsOption("abbrev"))
 }
 
+func TestExtType_Strings(t *testing.T) {
+	var v1 any
+	v1 = gcli.Strings{}
+	val, ok := v1.(flag.Value)
+	assert.True(t, ok)
+	assert.NotNil(t, val)
+
+	v1 = &gcli.Strings{}
+	val, ok = v1.(flag.Value)
+	assert.True(t, ok)
+	assert.NotNil(t, val)
+}
+
+func TestFlags_FromStruct_var_Strings(t *testing.T) {
+	type fileReplaceOpt struct {
+		// Dir   string       `flag:"desc=the directory for find and replace"`
+		Files gcli.Strings `flag:"desc=the files want replace content"`
+	}
+
+	opt := fileReplaceOpt{Files: make(gcli.Strings, 0)}
+
+	fs := gcli.NewFlags("test")
+	err := fs.FromStruct(&opt)
+
+	assert.NoErr(t, err)
+	assert.True(t, fs.HasOption("files"))
+}
+
 func TestFlags_FromStruct(t *testing.T) {
 	type userOpts struct {
 		Int  int    `flag:"name=int0;shorts=i;required=true;desc=int option message"`

gflag/opts.go

@@ -318,6 +318,26 @@ func (ops *CliOpts) uint64Opt(ptr *uint64, opt *CliOpt) {
 	opt.flag = ops.fSet.Lookup(name)
 }
 
+// FuncOptFn func option flag func type
+type FuncOptFn func(string) error
+
+// FuncOpt binding a func option flag
+//
+// Usage:
+//
+//	cmd.FuncOpt("name", "description ...", func(s string) error {
+//		// do something ...
+//		return nil
+//	})
+func (ops *CliOpts) FuncOpt(nameAndShorts, desc string, fn FuncOptFn, setFns ...CliOptFn) {
+	opt := NewOpt(nameAndShorts, desc, nil, setFns...)
+	name := ops.checkFlagInfo(opt)
+
+	// binding option to flag.FlagSet
+	ops.fSet.Func(name, opt.Desc, fn)
+	opt.flag = ops.fSet.Lookup(name)
+}
+
 // Var binding an custom var option flag
 func (ops *CliOpts) Var(ptr flag.Value, opt *CliOpt) { ops.varOpt(ptr, opt) }
 

gflag/parser.go

@@ -254,7 +254,7 @@ func (p *Parser) MustFromStruct(ptr any, ruleType ...uint8) {
 
 // FromStruct from struct tag binding options
 //
-// ## Named rule:
+// ## Named rule(default)
 //
 //	// tag format: name=val0;shorts=i;required=true;desc=a message
 //	type UserCmdOpts struct {
@@ -384,7 +384,7 @@ func (p *Parser) FromStruct(ptr any, ruleType ...uint8) (err error) {
 		case reflect.String:
 			p.StrVar((*string)(ptr), opt)
 		default:
-			return fmt.Errorf("field: %s - invalid type for binding flag", name)
+			return fmt.Errorf("field: %s - unsupport type(%s) for binding flag", name, ft.Kind())
 		}
 	}
 	return nil