🐛 fix: gflag - fix type name error on render help

Author: inhere

gflag/args_test.go

@@ -134,3 +134,51 @@ func TestArgument_SetValue(t *testing.T) {
 	assert.NoErr(t, err)
 	assert.Eq(t, 12, arg.Val())
 }
+
+func TestCliArgs_AddArg_panic(t *testing.T) {
+	is := assert.New(t)
+	c := gflag.Arguments{}
+	c.SetName("test")
+
+	arg := c.AddArg("arg0", "arg desc", true)
+	is.Eq(0, arg.Index())
+
+	ret := c.ArgByIndex(0)
+	is.Eq(ret, arg)
+
+	assert.PanicsMsg(t, func() {
+		c.ArgByIndex(1)
+	}, "gflag: get not exists argument #1")
+
+	arg = c.AddArg("arg1", "arg1 desc")
+	is.Eq(1, arg.Index())
+
+	ret = c.Arg("arg1")
+	is.Eq(ret, arg)
+
+	is.PanicsMsg(func() {
+		c.Arg("not-exist")
+	}, "gflag: get not exists argument 'not-exist'")
+
+	is.Len(c.Args(), 2)
+
+	is.PanicsMsg(func() {
+		c.AddArg("", "desc")
+	}, "gflag: the command argument name cannot be empty")
+
+	is.PanicsMsg(func() {
+		c.AddArg(":)&dfd", "desc")
+	}, "gflag: the argument name ':)&dfd' is invalid, must match: ^[a-zA-Z][\\w-]*$")
+
+	is.PanicsMsg(func() {
+		c.AddArg("arg1", "desc")
+	}, "gflag: the argument name 'arg1' already exists in command 'test'")
+	is.PanicsMsg(func() {
+		c.AddArg("arg2", "arg2 desc", true)
+	}, "gflag: required argument 'arg2' cannot be defined after optional argument")
+
+	c.AddArg("arg3", "arg3 desc", false, true)
+	is.PanicsMsg(func() {
+		c.AddArg("argN", "desc", true)
+	}, "gflag: have defined an array argument, you cannot add argument 'argN'")
+}

gflag/gflag.go

@@ -58,6 +58,12 @@ type Config struct {
 	DisableArg bool
 	// IndentLongOpt indent long option name on print help
 	IndentLongOpt bool
+	// EnhanceShort enhance short option parse. TODO
+	//
+	// 	0 - none
+	// 	1 - multi short bool options. eg: `-aux` = `-a -u -x`
+	// 	2 - allow name with value as one node. eg: `-Ostdout` = `-O stdout`
+	EnhanceShort uint8
 }
 
 // GetTagName get tag name, default is FlagTagName

gflag/help.go

@@ -2,7 +2,6 @@ package gflag
 
 import (
 	"bytes"
-	"flag"
 	"fmt"
 	"strings"
 
@@ -102,7 +101,7 @@ func (p *Parser) formatOneFlag(f *Flag) (s string) {
 	s = fmt.Sprintf("  <info>%s</>", fullName)
 
 	// - build flag type info
-	typeName, desc := flag.UnquoteUsage(f)
+	typeName, desc := UnquoteUsage(f)
 	// typeName: option value data type: int, string, ..., bool value will return ""
 	if !p.cfg.WithoutType && len(typeName) > 0 {
 		typeLen := len(typeName) + 1

gflag/util.go

@@ -84,3 +84,47 @@ func parseSimpleRule(rule string) (mp map[string]string) {
 	}
 	return arrutil.CombineToSMap(flagTagKeys1, ss)
 }
+
+// UnquoteUsage extracts a back-quoted name from the usage
+// string for a flag and returns it and the un-quoted usage.
+// Given "a `name` to show" it returns ("name", "a name to show").
+// If there are no back quotes, the name is an educated guess of the
+// type of the flag's value, or the empty string if the flag is boolean.
+//
+// Note: from go flag.UnquoteUsage()
+func UnquoteUsage(flag *Flag) (name string, usage string) {
+	// Look for a back-quoted name, but avoid the strings package.
+	usage = flag.Usage
+	for i := 0; i < len(usage); i++ {
+		if usage[i] == '`' {
+			for j := i + 1; j < len(usage); j++ {
+				if usage[j] == '`' {
+					name = usage[i+1 : j]
+					usage = usage[:i] + name + usage[j+1:]
+					return name, usage
+				}
+			}
+			break // Only one back quote; use type name.
+		}
+	}
+
+	// No explicit name, so use type if we can find one.
+	name = "value"
+	switch fv := flag.Value.(type) {
+	case boolFlag:
+		if fv.IsBoolFlag() {
+			name = ""
+		}
+	case *durationValue:
+		name = "duration"
+	case *float64Value:
+		name = "float"
+	case *intValue, *int64Value:
+		name = "int"
+	case *stringValue:
+		name = "string"
+	case *uintValue, *uint64Value:
+		name = "uint"
+	}
+	return
+}