1
package pflag
2

3
import (
4
	"bytes"
5
	"encoding/csv"
6
	"fmt"
7
	"sort"
8
	"strings"
9
)
10

11
// -- stringToString Value
12
type stringToStringValue struct {
13
	value   *map[string]string
14
	changed bool
15
}
16

17
func newStringToStringValue(val map[string]string, p *map[string]string) *stringToStringValue {
18
	ssv := new(stringToStringValue)
19
	ssv.value = p
20
	*ssv.value = val
21
	return ssv
22
}
23

24
// Format: a=1,b=2
25
func (s *stringToStringValue) Set(val string) error {
26
	var ss []string
27
	n := strings.Count(val, "=")
28
	switch n {
29
	case 0:
30
		return fmt.Errorf("%s must be formatted as key=value", val)
31
	case 1:
32
		ss = append(ss, strings.Trim(val, `"`))
33
	default:
34
		r := csv.NewReader(strings.NewReader(val))
35
		var err error
36
		ss, err = r.Read()
37
		if err != nil {
38
			return err
39
		}
40
	}
41

42
	out := make(map[string]string, len(ss))
43
	for _, pair := range ss {
44
		kv := strings.SplitN(pair, "=", 2)
45
		if len(kv) != 2 {
46
			return fmt.Errorf("%s must be formatted as key=value", pair)
47
		}
48
		out[kv[0]] = kv[1]
49
	}
50
	if !s.changed {
51
		*s.value = out
52
	} else {
53
		for k, v := range out {
54
			(*s.value)[k] = v
55
		}
56
	}
57
	s.changed = true
58
	return nil
59
}
60

61
func (s *stringToStringValue) Type() string {
62
	return "stringToString"
63
}
64

65
func (s *stringToStringValue) String() string {
66
	keys := make([]string, 0, len(*s.value))
67
	for k := range *s.value {
68
		keys = append(keys, k)
69
	}
70
	sort.Strings(keys)
71

72
	records := make([]string, 0, len(*s.value)>>1)
73
	for _, k := range keys {
74
		v := (*s.value)[k]
75
		records = append(records, k+"="+v)
76
	}
77

78
	var buf bytes.Buffer
79
	w := csv.NewWriter(&buf)
80
	if err := w.Write(records); err != nil {
81
		panic(err)
82
	}
83
	w.Flush()
84
	return "[" + strings.TrimSpace(buf.String()) + "]"
85
}
86

87
func stringToStringConv(val string) (interface{}, error) {
88
	val = strings.Trim(val, "[]")
89
	// An empty string would cause an empty map
90
	if len(val) == 0 {
91
		return map[string]string{}, nil
92
	}
93
	r := csv.NewReader(strings.NewReader(val))
94
	ss, err := r.Read()
95
	if err != nil {
96
		return nil, err
97
	}
98
	out := make(map[string]string, len(ss))
99
	for _, pair := range ss {
100
		kv := strings.SplitN(pair, "=", 2)
101
		if len(kv) != 2 {
102
			return nil, fmt.Errorf("%s must be formatted as key=value", pair)
103
		}
104
		out[kv[0]] = kv[1]
105
	}
106
	return out, nil
107
}
108

109
// GetStringToString return the map[string]string value of a flag with the given name
110
func (f *FlagSet) GetStringToString(name string) (map[string]string, error) {
111
	val, err := f.getFlagType(name, "stringToString", stringToStringConv)
112
	if err != nil {
113
		return map[string]string{}, err
114
	}
115
	return val.(map[string]string), nil
116
}
117

118
// StringToStringVar defines a string flag with specified name, default value, and usage string.
119
// The argument p points to a map[string]string variable in which to store the values of the multiple flags.
120
// The value of each argument will not try to be separated by comma
121
func (f *FlagSet) StringToStringVar(p *map[string]string, name string, value map[string]string, usage string) {
122
	f.VarP(newStringToStringValue(value, p), name, "", usage)
123
}
124

125
// StringToStringVarP is like StringToStringVar, but accepts a shorthand letter that can be used after a single dash.
126
func (f *FlagSet) StringToStringVarP(p *map[string]string, name, shorthand string, value map[string]string, usage string) {
127
	f.VarP(newStringToStringValue(value, p), name, shorthand, usage)
128
}
129

130
// StringToStringVar defines a string flag with specified name, default value, and usage string.
131
// The argument p points to a map[string]string variable in which to store the value of the flag.
132
// The value of each argument will not try to be separated by comma
133
func StringToStringVar(p *map[string]string, name string, value map[string]string, usage string) {
134
	CommandLine.VarP(newStringToStringValue(value, p), name, "", usage)
135
}
136

137
// StringToStringVarP is like StringToStringVar, but accepts a shorthand letter that can be used after a single dash.
138
func StringToStringVarP(p *map[string]string, name, shorthand string, value map[string]string, usage string) {
139
	CommandLine.VarP(newStringToStringValue(value, p), name, shorthand, usage)
140
}
141

142
// StringToString defines a string flag with specified name, default value, and usage string.
143
// The return value is the address of a map[string]string variable that stores the value of the flag.
144
// The value of each argument will not try to be separated by comma
145
func (f *FlagSet) StringToString(name string, value map[string]string, usage string) *map[string]string {
146
	p := map[string]string{}
147
	f.StringToStringVarP(&p, name, "", value, usage)
148
	return &p
149
}
150

151
// StringToStringP is like StringToString, but accepts a shorthand letter that can be used after a single dash.
152
func (f *FlagSet) StringToStringP(name, shorthand string, value map[string]string, usage string) *map[string]string {
153
	p := map[string]string{}
154
	f.StringToStringVarP(&p, name, shorthand, value, usage)
155
	return &p
156
}
157

158
// StringToString defines a string flag with specified name, default value, and usage string.
159
// The return value is the address of a map[string]string variable that stores the value of the flag.
160
// The value of each argument will not try to be separated by comma
161
func StringToString(name string, value map[string]string, usage string) *map[string]string {
162
	return CommandLine.StringToStringP(name, "", value, usage)
163
}
164

165
// StringToStringP is like StringToString, but accepts a shorthand letter that can be used after a single dash.
166
func StringToStringP(name, shorthand string, value map[string]string, usage string) *map[string]string {
167
	return CommandLine.StringToStringP(name, shorthand, value, usage)
168
}
169

170