feat(autocli): add map support

client/v2/autocli/flag/bool_to_value.go

@@ -0,0 +1,137 @@
+package flag
+
+import (
+	"github.com/spf13/pflag"
+	"strconv"
+)
+
+func newBoolToString[K bool, V string](val map[K]V, p *map[K]V) *genericMapValue[K, V] {
+	newBoolStringMap := newGenericMapValue(val, p)
+	newBoolStringMap.Options = genericMapValueOptions[K, V]{
+		genericType: "boolToString",
+		keyParser: func(s string) (K, error) {
+			value, err := strconv.ParseBool(s)
+			return K(value), err
+		},
+		valueParser: func(s string) (V, error) {
+			return V(s), nil
+		},
+	}
+	return newBoolStringMap
+}
+
+func BoolToStringP(flagSet *pflag.FlagSet, name, shorthand string, value map[bool]string, usage string) *map[bool]string {
+	p := make(map[bool]string)
+	flagSet.VarP(newBoolToString(value, &p), name, shorthand, usage)
+	return &p
+}
+
+func newBoolToInt32[K bool, V int32](val map[K]V, p *map[K]V) *genericMapValue[K, V] {
+	newBoolInt32Map := newGenericMapValue(val, p)
+	newBoolInt32Map.Options = genericMapValueOptions[K, V]{
+		genericType: "boolToInt32",
+		keyParser: func(s string) (K, error) {
+			value, err := strconv.ParseBool(s)
+			return K(value), err
+		},
+		valueParser: func(s string) (V, error) {
+			value, err := strconv.ParseInt(s, 10, 32)
+			return V(value), err
+		},
+	}
+	return newBoolInt32Map
+}
+
+func BoolToInt32P(flagSet *pflag.FlagSet, name, shorthand string, value map[bool]int32, usage string) *map[bool]int32 {
+	p := make(map[bool]int32)
+	flagSet.VarP(newBoolToInt32(value, &p), name, shorthand, usage)
+	return &p
+}
+
+func newBoolToInt64[K bool, V int64](val map[K]V, p *map[K]V) *genericMapValue[K, V] {
+	newBoolInt64Map := newGenericMapValue(val, p)
+	newBoolInt64Map.Options = genericMapValueOptions[K, V]{
+		genericType: "boolToInt64",
+		keyParser: func(s string) (K, error) {
+			value, err := strconv.ParseBool(s)
+			return K(value), err
+		},
+		valueParser: func(s string) (V, error) {
+			value, err := strconv.ParseInt(s, 10, 64)
+			return V(value), err
+		},
+	}
+	return newBoolInt64Map
+}
+
+func BoolToInt64P(flagSet *pflag.FlagSet, name, shorthand string, value map[bool]int64, usage string) *map[bool]int64 {
+	p := make(map[bool]int64)
+	flagSet.VarP(newBoolToInt64(value, &p), name, shorthand, usage)
+	return &p
+}
+
+func newBoolToUint32[K bool, V uint32](val map[K]V, p *map[K]V) *genericMapValue[K, V] {
+	newBoolUint32Map := newGenericMapValue(val, p)
+	newBoolUint32Map.Options = genericMapValueOptions[K, V]{
+		genericType: "boolToUint32",
+		keyParser: func(s string) (K, error) {
+			value, err := strconv.ParseBool(s)
+			return K(value), err
+		},
+		valueParser: func(s string) (V, error) {
+			value, err := strconv.ParseUint(s, 10, 32)
+			return V(value), err
+		},
+	}
+	return newBoolUint32Map
+}
+
+func BoolToUint32P(flagSet *pflag.FlagSet, name, shorthand string, value map[bool]uint32, usage string) *map[bool]uint32 {
+	p := make(map[bool]uint32)
+	flagSet.VarP(newBoolToUint32(value, &p), name, shorthand, usage)
+	return &p
+}
+
+func newBoolToUint64[K bool, V uint64](val map[K]V, p *map[K]V) *genericMapValue[K, V] {
+	newBoolUint64Map := newGenericMapValue(val, p)
+	newBoolUint64Map.Options = genericMapValueOptions[K, V]{
+		genericType: "boolToUint64",
+		keyParser: func(s string) (K, error) {
+			value, err := strconv.ParseBool(s)
+			return K(value), err
+		},
+		valueParser: func(s string) (V, error) {
+			value, err := strconv.ParseUint(s, 10, 64)
+			return V(value), err
+		},
+	}
+	return newBoolUint64Map
+}
+
+func BoolToUint64P(flagSet *pflag.FlagSet, name, shorthand string, value map[bool]uint64, usage string) *map[bool]uint64 {
+	p := make(map[bool]uint64)
+	flagSet.VarP(newBoolToUint64(value, &p), name, shorthand, usage)
+	return &p
+}
+
+func newBoolToBool[K bool, V bool](val map[K]V, p *map[K]V) *genericMapValue[K, V] {
+	newBoolBoolMap := newGenericMapValue(val, p)
+	newBoolBoolMap.Options = genericMapValueOptions[K, V]{
+		genericType: "boolToBool",
+		keyParser: func(s string) (K, error) {
+			value, err := strconv.ParseBool(s)
+			return K(value), err
+		},
+		valueParser: func(s string) (V, error) {
+			value, err := strconv.ParseBool(s)
+			return V(value), err
+		},
+	}
+	return newBoolBoolMap
+}
+
+func BoolToBoolP(flagSet *pflag.FlagSet, name, shorthand string, value map[bool]bool, usage string) *map[bool]bool {
+	p := make(map[bool]bool)
+	flagSet.VarP(newBoolToBool(value, &p), name, shorthand, usage)
+	return &p
+}

client/v2/autocli/flag/field.go

@@ -2,14 +2,15 @@ package flag
 
 import (
 	"context"
+	"strconv"
 
-	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
-	cosmos_proto "github.com/cosmos/cosmos-proto"
 	"github.com/spf13/pflag"
 	"google.golang.org/protobuf/proto"
 	"google.golang.org/protobuf/reflect/protoreflect"
 
+	autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
 	"cosmossdk.io/client/v2/internal/util"
+	cosmos_proto "github.com/cosmos/cosmos-proto"
 )
 
 // namingOptions specifies internal naming options for flags.
@@ -60,8 +61,14 @@ func (b *Builder) addFieldFlag(ctx context.Context, flagSet *pflag.FlagSet, fiel
 
 	// use the built-in pflag StringP, Int32P, etc. functions
 	var val HasValue
+
 	if field.IsList() {
 		val = bindSimpleListFlag(flagSet, field.Kind(), name, shorthand, usage)
+	}
+	if field.IsMap() {
+		keyKind := field.MapKey().Kind()
+		valKind := field.MapValue().Kind()
+		val = bindSimpleMapFlag(flagSet, keyKind, valKind, name, shorthand, usage)
 	} else {
 		val = bindSimpleFlag(flagSet, field.Kind(), name, shorthand, usage)
 	}
@@ -81,7 +88,65 @@ func (b *Builder) resolveFlagType(field protoreflect.FieldDescriptor) Type {
 		if typ != nil {
 			return compositeListType{simpleType: typ}
 		}
+		return nil
+	}
+	if field.IsMap() {
+		keyKind := field.MapKey().Kind()
+		valType := b.resolveFlagType(field.MapValue())
+		if valType != nil {
+			switch keyKind {
+			case protoreflect.StringKind:
+				ct := new(compositeMapType[string])
+				ct.keyValueResolver = func(s string) (string, error) { return s, nil }
+				ct.valueType = valType
+				ct.keyType = "string"
+				return ct
+			case protoreflect.Int32Kind, protoreflect.Sint32Kind, protoreflect.Sfixed32Kind:
+				ct := new(compositeMapType[int32])
+				ct.keyValueResolver = func(s string) (int32, error) {
+					i, err := strconv.ParseInt(s, 10, 32)
+					return int32(i), err
+				}
+				ct.valueType = valType
+				ct.keyType = "int32"
+				return ct
+			case protoreflect.Int64Kind, protoreflect.Sint64Kind, protoreflect.Sfixed64Kind:
+				ct := new(compositeMapType[int64])
+				ct.keyValueResolver = func(s string) (int64, error) {
+					i, err := strconv.ParseInt(s, 10, 64)
+					return i, err
+				}
+				ct.valueType = valType
+				ct.keyType = "int64"
+				return ct
+			case protoreflect.Uint32Kind, protoreflect.Fixed32Kind:
+				ct := new(compositeMapType[uint32])
+				ct.keyValueResolver = func(s string) (uint32, error) {
+					i, err := strconv.ParseUint(s, 10, 32)
+					return uint32(i), err
+				}
+				ct.valueType = valType
+				ct.keyType = "uint32"
+				return ct
+			case protoreflect.Uint64Kind, protoreflect.Fixed64Kind:
+				ct := new(compositeMapType[uint64])
+				ct.keyValueResolver = func(s string) (uint64, error) {
+					i, err := strconv.ParseUint(s, 10, 64)
+					return i, err
+				}
+				ct.valueType = valType
+				ct.keyType = "uint64"
+				return ct
+			case protoreflect.BoolKind:
+				ct := new(compositeMapType[bool])
+				ct.keyValueResolver = strconv.ParseBool
+				ct.valueType = valType
+				ct.keyType = "bool"
+				return ct
+			}
+			return nil
 
+		}
 		return nil
 	}
 
@@ -107,7 +172,6 @@ func (b *Builder) resolveFlagTypeBasic(field protoreflect.FieldDescriptor) Type
 		if flagType, ok := b.messageFlagTypes[field.Message().FullName()]; ok {
 			return flagType
 		}
-
 		return jsonMessageFlagType{
 			messageDesc: field.Message(),
 		}