add a new type StringArray

5 files changed, 338 insertions, 24 deletions

diff --git a/flag.go b/flag.go
index eb143d7..c28f3bd 100644
--- a/flag.go
+++ b/flag.go
@@ -434,7 +434,7 @@ func (f *Flag) defaultIsZeroValue() bool {
 		return f.DefValue == ""
 	case *ipValue, *ipMaskValue, *ipNetValue:
 		return f.DefValue == "<nil>"
-	case *intSliceValue, *stringSliceValue:
+	case *intSliceValue, *stringSliceValue, *stringArrayValue:
 		return f.DefValue == "[]"
 	default:
 		return true
diff --git a/flag_test.go b/flag_test.go
index 86b37e5..1befb94 100644
--- a/flag_test.go
+++ b/flag_test.go
@@ -874,23 +874,24 @@ func TestHiddenFlagUsage(t *testing.T) {
 	}
 }
 
-const defaultOutput = `      --A                     for bootstrapping, allow 'any' type
-      --Alongflagname         disable bounds checking
-  -C, --CCC                   a boolean defaulting to true (default true)
-      --D path                set relative path for local imports
-      --F number              a non-zero number (default 2.7)
-      --G float               a float that defaults to zero
-      --IP ip                 IP address with no default
-      --IPMask ipMask         Netmask address with no default
-      --IPNet ipNet           IP network with no default
-      --Ints intSlice         int slice with zero default
-      --N int                 a non-zero int (default 27)
-      --ND1 string[="bar"]    a string with NoOptDefVal (default "foo")
-      --ND2 num[=4321]        a num with NoOptDefVal (default 1234)
-      --Strings stringSlice   string slice with zero default
-      --Z int                 an int that defaults to zero
-      --custom custom         custom Value implementation
-      --maxT timeout          set timeout for dial
+const defaultOutput = `      --A                         for bootstrapping, allow 'any' type
+      --Alongflagname             disable bounds checking
+  -C, --CCC                       a boolean defaulting to true (default true)
+      --D path                    set relative path for local imports
+      --F number                  a non-zero number (default 2.7)
+      --G float                   a float that defaults to zero
+      --IP ip                     IP address with no default
+      --IPMask ipMask             Netmask address with no default
+      --IPNet ipNet               IP network with no default
+      --Ints intSlice             int slice with zero default
+      --N int                     a non-zero int (default 27)
+      --ND1 string[="bar"]        a string with NoOptDefVal (default "foo")
+      --ND2 num[=4321]            a num with NoOptDefVal (default 1234)
+      --StringArray stringArray   string array with zero default
+      --StringSlice stringSlice   string slice with zero default
+      --Z int                     an int that defaults to zero
+      --custom custom             custom Value implementation
+      --maxT timeout              set timeout for dial
 `
 
 // Custom value that satisfies the Value interface.
@@ -927,7 +928,8 @@ func TestPrintDefaults(t *testing.T) {
 	fs.Lookup("ND1").NoOptDefVal = "bar"
 	fs.Int("ND2", 1234, "a `num` with NoOptDefVal")
 	fs.Lookup("ND2").NoOptDefVal = "4321"
-	fs.StringSlice("Strings", []string{}, "string slice with zero default")
+	fs.StringSlice("StringSlice", []string{}, "string slice with zero default")
+	fs.StringArray("StringArray", []string{}, "string array with zero default")
 
 	var cv customValue
 	fs.Var(&cv, "custom", "custom Value implementation")
diff --git a/string_array.go b/string_array.go
new file mode 100644
index 0000000..f320f2e
--- /dev/null
+++ b/string_array.go
@@ -0,0 +1,110 @@
+package pflag
+
+import (
+	"fmt"
+	"strings"
+)
+
+var _ = fmt.Fprint
+
+// -- stringArray Value
+type stringArrayValue struct {
+	value   *[]string
+	changed bool
+}
+
+func newStringArrayValue(val []string, p *[]string) *stringArrayValue {
+	ssv := new(stringArrayValue)
+	ssv.value = p
+	*ssv.value = val
+	return ssv
+}
+
+func (s *stringArrayValue) Set(val string) error {
+	if !s.changed {
+		*s.value = []string{val}
+		s.changed = true
+	} else {
+		*s.value = append(*s.value, val)
+	}
+	return nil
+}
+
+func (s *stringArrayValue) Type() string {
+	return "stringArray"
+}
+
+func (s *stringArrayValue) String() string {
+	str, _ := writeAsCSV(*s.value)
+	return "[" + str + "]"
+}
+
+func stringArrayConv(sval string) (interface{}, error) {
+	sval = strings.Trim(sval, "[]")
+	// An empty string would cause a array with one (empty) string
+	if len(sval) == 0 {
+		return []string{}, nil
+	}
+	return readAsCSV(sval)
+}
+
+// GetStringArray return the []string value of a flag with the given name
+func (f *FlagSet) GetStringArray(name string) ([]string, error) {
+	val, err := f.getFlagType(name, "stringArray", stringArrayConv)
+	if err != nil {
+		return []string{}, err
+	}
+	return val.([]string), nil
+}
+
+// StringArrayVar defines a string flag with specified name, default value, and usage string.
+// The argument p points to a []string variable in which to store the values of the multiple flags.
+// The value of each argument will not try to be separated by comma
+func (f *FlagSet) StringArrayVar(p *[]string, name string, value []string, usage string) {
+	f.VarP(newStringArrayValue(value, p), name, "", usage)
+}
+
+// StringArrayVarP is like StringArrayVar, but accepts a shorthand letter that can be used after a single dash.
+func (f *FlagSet) StringArrayVarP(p *[]string, name, shorthand string, value []string, usage string) {
+	f.VarP(newStringArrayValue(value, p), name, shorthand, usage)
+}
+
+// StringArrayVar defines a string flag with specified name, default value, and usage string.
+// The argument p points to a []string variable in which to store the value of the flag.
+// The value of each argument will not try to be separated by comma
+func StringArrayVar(p *[]string, name string, value []string, usage string) {
+	CommandLine.VarP(newStringArrayValue(value, p), name, "", usage)
+}
+
+// StringArrayVarP is like StringArrayVar, but accepts a shorthand letter that can be used after a single dash.
+func StringArrayVarP(p *[]string, name, shorthand string, value []string, usage string) {
+	CommandLine.VarP(newStringArrayValue(value, p), name, shorthand, usage)
+}
+
+// StringArray defines a string flag with specified name, default value, and usage string.
+// The return value is the address of a []string variable that stores the value of the flag.
+// The value of each argument will not try to be separated by comma
+func (f *FlagSet) StringArray(name string, value []string, usage string) *[]string {
+	p := []string{}
+	f.StringArrayVarP(&p, name, "", value, usage)
+	return &p
+}
+
+// StringArrayP is like StringArray, but accepts a shorthand letter that can be used after a single dash.
+func (f *FlagSet) StringArrayP(name, shorthand string, value []string, usage string) *[]string {
+	p := []string{}
+	f.StringArrayVarP(&p, name, shorthand, value, usage)
+	return &p
+}
+
+// StringArray defines a string flag with specified name, default value, and usage string.
+// The return value is the address of a []string variable that stores the value of the flag.
+// The value of each argument will not try to be separated by comma
+func StringArray(name string, value []string, usage string) *[]string {
+	return CommandLine.StringArrayP(name, "", value, usage)
+}
+
+// StringArrayP is like StringArray, but accepts a shorthand letter that can be used after a single dash.
+func StringArrayP(name, shorthand string, value []string, usage string) *[]string {
+	return CommandLine.StringArrayP(name, shorthand, value, usage)
+}
diff --git a/string_array_test.go b/string_array_test.go
new file mode 100644
index 0000000..3e3eb74
--- /dev/null
+++ b/string_array_test.go
@@ -0,0 +1,194 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package pflag
+
+import (
+	"fmt"
+	"testing"
+)
+
+func setUpSAFlagSet(sap *[]string) *FlagSet {
+	f := NewFlagSet("test", ContinueOnError)
+	f.StringArrayVar(sap, "sa", []string{}, "Command separated list!")
+	return f
+}
+
+func setUpSAFlagSetWithDefault(sap *[]string) *FlagSet {
+	f := NewFlagSet("test", ContinueOnError)
+	f.StringArrayVar(sap, "sa", []string{"default", "values"}, "Command separated list!")
+	return f
+}
+
+func TestEmptySA(t *testing.T) {
+	var sa []string
+	f := setUpSAFlagSet(&sa)
+	err := f.Parse([]string{})
+	if err != nil {
+		t.Fatal("expected no error; got", err)
+	}
+
+	getSA, err := f.GetStringArray("sa")
+	if err != nil {
+		t.Fatal("got an error from GetStringArray():", err)
+	}
+	if len(getSA) != 0 {
+		t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
+	}
+}
+
+func TestEmptySAValue(t *testing.T) {
+	var sa []string
+	f := setUpSAFlagSet(&sa)
+	err := f.Parse([]string{"--sa="})
+	if err != nil {
+		t.Fatal("expected no error; got", err)
+	}
+
+	getSA, err := f.GetStringArray("sa")
+	if err != nil {
+		t.Fatal("got an error from GetStringArray():", err)
+	}
+	if len(getSA) != 0 {
+		t.Fatalf("got sa %v with len=%d but expected length=0", getSA, len(getSA))
+	}
+}
+
+func TestSADefault(t *testing.T) {
+	var sa []string
+	f := setUpSAFlagSetWithDefault(&sa)
+
+	vals := []string{"default", "values"}
+
+	err := f.Parse([]string{})
+	if err != nil {
+		t.Fatal("expected no error; got", err)
+	}
+	for i, v := range sa {
+		if vals[i] != v {
+			t.Fatalf("expected sa[%d] to be %s but got: %s", i, vals[i], v)
+		}
+	}
+
+	getSA, err := f.GetStringArray("sa")
+	if err != nil {
+		t.Fatal("got an error from GetStringArray():", err)
+	}
+	for i, v := range getSA {
+		if vals[i] != v {
+			t.Fatalf("expected sa[%d] to be %s from GetStringArray but got: %s", i, vals[i], v)
+		}
+	}
+}
+
+func TestSAWithDefault(t *testing.T) {
+	var sa []string
+	f := setUpSAFlagSetWithDefault(&sa)
+
+	val := "one"
+	arg := fmt.Sprintf("--sa=%s", val)
+	err := f.Parse([]string{arg})
+	if err != nil {
+		t.Fatal("expected no error; got", err)
+	}
+
+	if len(sa) != 1 {
+		t.Fatalf("expected number of values to be %d but %d", 1, len(sa))
+	}
+
+	if sa[0] != val {
+		t.Fatalf("expected value to be %s but got: %s", sa[0], val)
+	}
+
+	getSA, err := f.GetStringArray("sa")
+	if err != nil {
+		t.Fatal("got an error from GetStringArray():", err)
+	}
+
+	if len(getSA) != 1 {
+		t.Fatalf("expected number of values to be %d but %d", 1, len(getSA))
+	}
+
+	if getSA[0] != val {
+		t.Fatalf("expected value to be %s but got: %s", getSA[0], val)
+	}
+}
+
+func TestSACalledTwice(t *testing.T) {
+	var sa []string
+	f := setUpSAFlagSet(&sa)
+
+	in := []string{"one", "two"}
+	expected := []string{"one", "two"}
+	argfmt := "--sa=%s"
+	arg1 := fmt.Sprintf(argfmt, in[0])
+	arg2 := fmt.Sprintf(argfmt, in[1])
+	err := f.Parse([]string{arg1, arg2})
+	if err != nil {
+		t.Fatal("expected no error; got", err)
+	}
+
+	if len(expected) != len(sa) {
+		t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
+	}
+	for i, v := range sa {
+		if expected[i] != v {
+			t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
+		}
+	}
+
+	values, err := f.GetStringArray("sa")
+	if err != nil {
+		t.Fatal("expected no error; got", err)
+	}
+
+	if len(expected) != len(values) {
+		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(sa))
+	}
+	for i, v := range values {
+		if expected[i] != v {
+			t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
+		}
+	}
+}
+
+func TestSAWithSpecialChar(t *testing.T) {
+	var sa []string
+	f := setUpSAFlagSet(&sa)
+
+	in := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
+	expected := []string{"one,two", `"three"`, `"four,five",six`, "seven eight"}
+	argfmt := "--sa=%s"
+	arg1 := fmt.Sprintf(argfmt, in[0])
+	arg2 := fmt.Sprintf(argfmt, in[1])
+	arg3 := fmt.Sprintf(argfmt, in[2])
+	arg4 := fmt.Sprintf(argfmt, in[3])
+	err := f.Parse([]string{arg1, arg2, arg3, arg4})
+	if err != nil {
+		t.Fatal("expected no error; got", err)
+	}
+
+	if len(expected) != len(sa) {
+		t.Fatalf("expected number of sa to be %d but got: %d", len(expected), len(sa))
+	}
+	for i, v := range sa {
+		if expected[i] != v {
+			t.Fatalf("expected sa[%d] to be %s but got: %s", i, expected[i], v)
+		}
+	}
+
+	values, err := f.GetStringArray("sa")
+	if err != nil {
+		t.Fatal("expected no error; got", err)
+	}
+
+	if len(expected) != len(values) {
+		t.Fatalf("expected number of values to be %d but got: %d", len(expected), len(values))
+	}
+	for i, v := range values {
+		if expected[i] != v {
+			t.Fatalf("expected got sa[%d] to be %s but got: %s", i, expected[i], v)
+		}
+	}
+}
diff --git a/string_slice.go b/string_slice.go
index 927a440..51e3c5d 100644
--- a/string_slice.go
+++ b/string_slice.go
@@ -31,6 +31,17 @@ func readAsCSV(val string) ([]string, error) {
 	return csvReader.Read()
 }
 
+func writeAsCSV(vals []string) (string, error) {
+	b := &bytes.Buffer{}
+	w := csv.NewWriter(b)
+	err := w.Write(vals)
+	if err != nil {
+		return "", err
+	}
+	w.Flush()
+	return strings.TrimSuffix(b.String(), fmt.Sprintln()), nil
+}
+
 func (s *stringSliceValue) Set(val string) error {
 	v, err := readAsCSV(val)
 	if err != nil {
@@ -50,11 +61,8 @@ func (s *stringSliceValue) Type() string {
 }
 
 func (s *stringSliceValue) String() string {
-	b := &bytes.Buffer{}
-	w := csv.NewWriter(b)
-	w.Write(*s.value)
-	w.Flush()
-	return "[" + strings.TrimSuffix(b.String(), fmt.Sprintln()) + "]"
+	str, _ := writeAsCSV(*s.value)
+	return "[" + str + "]"
 }
 
 func stringSliceConv(sval string) (interface{}, error) {