Merge lp:~rogpeppe/gnuflag/001-merge-go-updates into lp:gnuflag

[Roger Peppe]

merge updates from Go tree

The flag package in the Go source tree has had
a bunch of updates. This change brings gnuflag
up to date with that.

https://codereview.appspot.com/199070043/

[Roger Peppe (rogpeppe)]

Please take a look.

[Roger Peppe (rogpeppe)]

Reviewers: mp+247632_code.launchpad.net,

Message:
Please take a look.

Description:
merge updates from Go tree

The flag package in the Go source tree has had
a bunch of updates. This change brings gnuflag
up to date with that.

https://code.launchpad.net/~rogpeppe/gnuflag/001-merge-go-updates/+merge/247632

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/199070043/

Affected files (+194, -58 lines):
   A [revision details]
   M export_test.go
   M flag.go
   M flag_test.go

[Martin Hilton (martin-hilton)]

LGTM

https://codereview.appspot.com/199070043/

[Jay R. Wren (evarlast)]

LGTM

https://codereview.appspot.com/199070043/

[Roger Peppe (rogpeppe)]

*** Submitted:

merge updates from Go tree

The flag package in the Go source tree has had
a bunch of updates. This change brings gnuflag
up to date with that.

R=martin.hilton, jay.wren
CC=
https://codereview.appspot.com/199070043

https://codereview.appspot.com/199070043/

=== modified file 'export_test.go'
--- export_test.go	2012-02-01 11:10:44 +0000
+++ export_test.go	2015-01-26 18:18:29 +0000
@@ -14,11 +14,6 @@
 // After calling ResetForTesting, parse errors in flag handling will not
 // exit the program.
 func ResetForTesting(usage func()) {
-	commandLine = NewFlagSet(os.Args[0], ContinueOnError)
+	CommandLine = NewFlagSet(os.Args[0], ContinueOnError)
 	Usage = usage
 }
-
-// CommandLine returns the default FlagSet.
-func CommandLine() *FlagSet {
-	return commandLine
-}

=== modified file 'flag.go'
--- flag.go	2012-10-02 13:48:04 +0000
+++ flag.go	2015-01-26 18:18:29 +0000
@@ -23,7 +23,7 @@
 
 	Flag parsing stops after the terminator "--", or just before the first
 	non-flag argument ("-" is a non-flag argument) if the interspersed
-	argument to Parse is false. 
+	argument to Parse is false.
 */
 package gnuflag
 
@@ -40,7 +40,8 @@
 	"unicode/utf8"
 )
 
-// ErrHelp is the error returned if the flag -help is invoked but no such flag is defined.
+// ErrHelp is the error returned if the -help or -h flag is invoked
+// but no such flag is defined.
 var ErrHelp = errors.New("flag: help requested")
 
 // -- bool Value
@@ -57,8 +58,19 @@
 	return err
 }
 
+func (b *boolValue) Get() interface{} { return bool(*b) }
+
 func (b *boolValue) String() string { return fmt.Sprintf("%v", *b) }
 
+func (b *boolValue) IsBoolFlag() bool { return true }
+
+// optional interface to indicate boolean flags that can be
+// supplied without "=value" text
+type boolFlag interface {
+	Value
+	IsBoolFlag() bool
+}
+
 // -- int Value
 type intValue int
 
@@ -73,6 +85,8 @@
 	return err
 }
 
+func (i *intValue) Get() interface{} { return int(*i) }
+
 func (i *intValue) String() string { return fmt.Sprintf("%v", *i) }
 
 // -- int64 Value
@@ -89,6 +103,8 @@
 	return err
 }
 
+func (i *int64Value) Get() interface{} { return int64(*i) }
+
 func (i *int64Value) String() string { return fmt.Sprintf("%v", *i) }
 
 // -- uint Value
@@ -105,6 +121,8 @@
 	return err
 }
 
+func (i *uintValue) Get() interface{} { return uint(*i) }
+
 func (i *uintValue) String() string { return fmt.Sprintf("%v", *i) }
 
 // -- uint64 Value
@@ -121,6 +139,8 @@
 	return err
 }
 
+func (i *uint64Value) Get() interface{} { return uint64(*i) }
+
 func (i *uint64Value) String() string { return fmt.Sprintf("%v", *i) }
 
 // -- string Value
@@ -136,6 +156,8 @@
 	return nil
 }
 
+func (s *stringValue) Get() interface{} { return string(*s) }
+
 func (s *stringValue) String() string { return fmt.Sprintf("%s", *s) }
 
 // -- float64 Value
@@ -152,6 +174,8 @@
 	return err
 }
 
+func (f *float64Value) Get() interface{} { return float64(*f) }
+
 func (f *float64Value) String() string { return fmt.Sprintf("%v", *f) }
 
 // -- time.Duration Value
@@ -168,6 +192,8 @@
 	return err
 }
 
+func (d *durationValue) Get() interface{} { return time.Duration(*d) }
+
 func (d *durationValue) String() string { return (*time.Duration)(d).String() }
 
 // Value is the interface to the dynamic value stored in a flag.
@@ -177,6 +203,15 @@
 	Set(string) error
 }
 
+// Getter is an interface that allows the contents of a Value to be retrieved.
+// It wraps the Value interface, rather than being part of it, because it
+// appeared after Go 1 and its compatibility rules. All Value types provided
+// by this package satisfy the Getter interface.
+type Getter interface {
+	Value
+	Get() interface{}
+}
+
 // ErrorHandling defines how to handle flag parsing errors.
 type ErrorHandling int
 
@@ -254,7 +289,7 @@
 // VisitAll visits the command-line flags in lexicographical order, calling
 // fn for each.  It visits all flags, even those not set.
 func VisitAll(fn func(*Flag)) {
-	commandLine.VisitAll(fn)
+	CommandLine.VisitAll(fn)
 }
 
 // Visit visits the flags in lexicographical order, calling fn for each.
@@ -268,7 +303,7 @@
 // Visit visits the command-line flags in lexicographical order, calling fn
 // for each.  It visits only those flags that have been set.
 func Visit(fn func(*Flag)) {
-	commandLine.Visit(fn)
+	CommandLine.Visit(fn)
 }
 
 // Lookup returns the Flag structure of the named flag, returning nil if none exists.
@@ -279,7 +314,7 @@
 // Lookup returns the Flag structure of the named command-line flag,
 // returning nil if none exists.
 func Lookup(name string) *Flag {
-	return commandLine.formal[name]
+	return CommandLine.formal[name]
 }
 
 // Set sets the value of the named flag.
@@ -301,7 +336,7 @@
 
 // Set sets the value of the named command-line flag.
 func Set(name, value string) error {
-	return commandLine.Set(name, value)
+	return CommandLine.Set(name, value)
 }
 
 // flagsByLength is a slice of flags implementing sort.Interface,
@@ -377,16 +412,20 @@
 
 // PrintDefaults prints to standard error the default values of all defined command-line flags.
 func PrintDefaults() {
-	commandLine.PrintDefaults()
+	CommandLine.PrintDefaults()
 }
 
 // defaultUsage is the default function to print a usage message.
 func defaultUsage(f *FlagSet) {
-	fmt.Fprintf(f.out(), "Usage of %s:\n", f.name)
+	if f.name == "" {
+		fmt.Fprintf(f.out(), "Usage:\n")
+	} else {
+		fmt.Fprintf(f.out(), "Usage of %s:\n", f.name)
+	}
 	f.PrintDefaults()
 }
 
-// NOTE: Usage is not just defaultUsage(commandLine)
+// NOTE: Usage is not just defaultUsage(CommandLine)
 // because it serves (via godoc flag Usage) as the example
 // for how to write your own usage function.
 
@@ -401,7 +440,7 @@
 func (f *FlagSet) NFlag() int { return len(f.actual) }
 
 // NFlag returns the number of command-line flags that have been set.
-func NFlag() int { return len(commandLine.actual) }
+func NFlag() int { return len(CommandLine.actual) }
 
 // Arg returns the i'th argument.  Arg(0) is the first remaining argument
 // after flags have been processed.
@@ -415,20 +454,20 @@
 // Arg returns the i'th command-line argument.  Arg(0) is the first remaining argument
 // after flags have been processed.
 func Arg(i int) string {
-	return commandLine.Arg(i)
+	return CommandLine.Arg(i)
 }
 
 // NArg is the number of arguments remaining after flags have been processed.
 func (f *FlagSet) NArg() int { return len(f.args) }
 
 // NArg is the number of arguments remaining after flags have been processed.
-func NArg() int { return len(commandLine.args) }
+func NArg() int { return len(CommandLine.args) }
 
 // Args returns the non-flag arguments.
 func (f *FlagSet) Args() []string { return f.args }
 
 // Args returns the non-flag command-line arguments.
-func Args() []string { return commandLine.args }
+func Args() []string { return CommandLine.args }
 
 // BoolVar defines a bool flag with specified name, default value, and usage string.
 // The argument p points to a bool variable in which to store the value of the flag.
@@ -439,7 +478,7 @@
 // BoolVar defines a bool flag with specified name, default value, and usage string.
 // The argument p points to a bool variable in which to store the value of the flag.
 func BoolVar(p *bool, name string, value bool, usage string) {
-	commandLine.Var(newBoolValue(value, p), name, usage)
+	CommandLine.Var(newBoolValue(value, p), name, usage)
 }
 
 // Bool defines a bool flag with specified name, default value, and usage string.
@@ -453,7 +492,7 @@
 // Bool defines a bool flag with specified name, default value, and usage string.
 // The return value is the address of a bool variable that stores the value of the flag.
 func Bool(name string, value bool, usage string) *bool {
-	return commandLine.Bool(name, value, usage)
+	return CommandLine.Bool(name, value, usage)
 }
 
 // IntVar defines an int flag with specified name, default value, and usage string.
@@ -465,7 +504,7 @@
 // IntVar defines an int flag with specified name, default value, and usage string.
 // The argument p points to an int variable in which to store the value of the flag.
 func IntVar(p *int, name string, value int, usage string) {
-	commandLine.Var(newIntValue(value, p), name, usage)
+	CommandLine.Var(newIntValue(value, p), name, usage)
 }
 
 // Int defines an int flag with specified name, default value, and usage string.
@@ -479,7 +518,7 @@
 // Int defines an int flag with specified name, default value, and usage string.
 // The return value is the address of an int variable that stores the value of the flag.
 func Int(name string, value int, usage string) *int {
-	return commandLine.Int(name, value, usage)
+	return CommandLine.Int(name, value, usage)
 }
 
 // Int64Var defines an int64 flag with specified name, default value, and usage string.
@@ -491,7 +530,7 @@
 // Int64Var defines an int64 flag with specified name, default value, and usage string.
 // The argument p points to an int64 variable in which to store the value of the flag.
 func Int64Var(p *int64, name string, value int64, usage string) {
-	commandLine.Var(newInt64Value(value, p), name, usage)
+	CommandLine.Var(newInt64Value(value, p), name, usage)
 }
 
 // Int64 defines an int64 flag with specified name, default value, and usage string.
@@ -505,7 +544,7 @@
 // Int64 defines an int64 flag with specified name, default value, and usage string.
 // The return value is the address of an int64 variable that stores the value of the flag.
 func Int64(name string, value int64, usage string) *int64 {
-	return commandLine.Int64(name, value, usage)
+	return CommandLine.Int64(name, value, usage)
 }
 
 // UintVar defines a uint flag with specified name, default value, and usage string.
@@ -517,7 +556,7 @@
 // UintVar defines a uint flag with specified name, default value, and usage string.
 // The argument p points to a uint  variable in which to store the value of the flag.
 func UintVar(p *uint, name string, value uint, usage string) {
-	commandLine.Var(newUintValue(value, p), name, usage)
+	CommandLine.Var(newUintValue(value, p), name, usage)
 }
 
 // Uint defines a uint flag with specified name, default value, and usage string.
@@ -531,7 +570,7 @@
 // Uint defines a uint flag with specified name, default value, and usage string.
 // The return value is the address of a uint  variable that stores the value of the flag.
 func Uint(name string, value uint, usage string) *uint {
-	return commandLine.Uint(name, value, usage)
+	return CommandLine.Uint(name, value, usage)
 }
 
 // Uint64Var defines a uint64 flag with specified name, default value, and usage string.
@@ -543,7 +582,7 @@
 // Uint64Var defines a uint64 flag with specified name, default value, and usage string.
 // The argument p points to a uint64 variable in which to store the value of the flag.
 func Uint64Var(p *uint64, name string, value uint64, usage string) {
-	commandLine.Var(newUint64Value(value, p), name, usage)
+	CommandLine.Var(newUint64Value(value, p), name, usage)
 }
 
 // Uint64 defines a uint64 flag with specified name, default value, and usage string.
@@ -557,7 +596,7 @@
 // Uint64 defines a uint64 flag with specified name, default value, and usage string.
 // The return value is the address of a uint64 variable that stores the value of the flag.
 func Uint64(name string, value uint64, usage string) *uint64 {
-	return commandLine.Uint64(name, value, usage)
+	return CommandLine.Uint64(name, value, usage)
 }
 
 // StringVar defines a string flag with specified name, default value, and usage string.
@@ -569,7 +608,7 @@
 // StringVar 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.
 func StringVar(p *string, name string, value string, usage string) {
-	commandLine.Var(newStringValue(value, p), name, usage)
+	CommandLine.Var(newStringValue(value, p), name, usage)
 }
 
 // String defines a string flag with specified name, default value, and usage string.
@@ -583,7 +622,7 @@
 // String 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.
 func String(name string, value string, usage string) *string {
-	return commandLine.String(name, value, usage)
+	return CommandLine.String(name, value, usage)
 }
 
 // Float64Var defines a float64 flag with specified name, default value, and usage string.
@@ -595,7 +634,7 @@
 // Float64Var defines a float64 flag with specified name, default value, and usage string.
 // The argument p points to a float64 variable in which to store the value of the flag.
 func Float64Var(p *float64, name string, value float64, usage string) {
-	commandLine.Var(newFloat64Value(value, p), name, usage)
+	CommandLine.Var(newFloat64Value(value, p), name, usage)
 }
 
 // Float64 defines a float64 flag with specified name, default value, and usage string.
@@ -609,7 +648,7 @@
 // Float64 defines a float64 flag with specified name, default value, and usage string.
 // The return value is the address of a float64 variable that stores the value of the flag.
 func Float64(name string, value float64, usage string) *float64 {
-	return commandLine.Float64(name, value, usage)
+	return CommandLine.Float64(name, value, usage)
 }
 
 // DurationVar defines a time.Duration flag with specified name, default value, and usage string.
@@ -621,7 +660,7 @@
 // DurationVar defines a time.Duration flag with specified name, default value, and usage string.
 // The argument p points to a time.Duration variable in which to store the value of the flag.
 func DurationVar(p *time.Duration, name string, value time.Duration, usage string) {
-	commandLine.Var(newDurationValue(value, p), name, usage)
+	CommandLine.Var(newDurationValue(value, p), name, usage)
 }
 
 // Duration defines a time.Duration flag with specified name, default value, and usage string.
@@ -635,7 +674,7 @@
 // Duration defines a time.Duration flag with specified name, default value, and usage string.
 // The return value is the address of a time.Duration variable that stores the value of the flag.
 func Duration(name string, value time.Duration, usage string) *time.Duration {
-	return commandLine.Duration(name, value, usage)
+	return CommandLine.Duration(name, value, usage)
 }
 
 // Var defines a flag with the specified name and usage string. The type and
@@ -665,7 +704,7 @@
 // of strings by giving the slice the methods of Value; in particular, Set would
 // decompose the comma-separated string into the slice.
 func Var(value Value, name string, usage string) {
-	commandLine.Var(value, name, usage)
+	CommandLine.Var(value, name, usage)
 }
 
 // failf prints to standard error a formatted error and usage message and
@@ -678,18 +717,20 @@
 }
 
 // usage calls the Usage method for the flag set, or the usage function if
-// the flag set is commandLine.
+// the flag set is CommandLine.
 func (f *FlagSet) usage() {
-	if f == commandLine {
-		Usage()
-	} else if f.Usage == nil {
-		defaultUsage(f)
+	if f.Usage == nil {
+		if f == CommandLine {
+			Usage()
+		} else {
+			defaultUsage(f)
+		}
 	} else {
 		f.Usage()
 	}
 }
 
-func (f *FlagSet) parseOneGnu() (flagName string, long, finished bool, err error) {
+func (f *FlagSet) parseOne() (flagName string, long, finished bool, err error) {
 	if len(f.procArgs) == 0 {
 		finished = true
 		return
@@ -761,7 +802,7 @@
 	return "-" + name
 }
 
-func (f *FlagSet) parseGnuFlagArg(name string, long bool) (finished bool, err error) {
+func (f *FlagSet) parseFlagArg(name string, long bool) (finished bool, err error) {
 	m := f.formal
 	flag, alreadythere := m[name] // BUG
 	if !alreadythere {
@@ -772,10 +813,12 @@
 		// TODO print --xxx when flag is more than one rune.
 		return false, f.failf("flag provided but not defined: %s", flagWithMinus(name))
 	}
-	if fv, ok := flag.Value.(*boolValue); ok && !strings.HasPrefix(f.procFlag, "=") {
+	if fv, ok := flag.Value.(boolFlag); ok && fv.IsBoolFlag() && !strings.HasPrefix(f.procFlag, "=") {
 		// special case: doesn't need an arg, and an arg hasn't
 		// been provided explicitly.
-		fv.Set("true")
+		if err := fv.Set("true"); err != nil {
+			return false, f.failf("invalid boolean flag %s: %v", name, err)
+		}
 	} else {
 		// It must have a value, which might be the next argument.
 		var hasValue bool
@@ -814,7 +857,7 @@
 // Parse parses flag definitions from the argument list, which should not
 // include the command name.  Must be called after all flags in the FlagSet
 // are defined and before flags are accessed by the program.
-// The return value will be ErrHelp if --help was set but not defined.
+// The return value will be ErrHelp if --help or -h was set but not defined.
 // If allowIntersperse is set, arguments and flags can be interspersed, that
 // is flags can follow positional arguments.
 func (f *FlagSet) Parse(allowIntersperse bool, arguments []string) error {
@@ -824,10 +867,10 @@
 	f.args = nil
 	f.allowIntersperse = allowIntersperse
 	for {
-		name, long, finished, err := f.parseOneGnu()
+		name, long, finished, err := f.parseOne()
 		if !finished {
 			if name != "" {
-				finished, err = f.parseGnuFlagArg(name, long)
+				finished, err = f.parseFlagArg(name, long)
 			}
 		}
 		if err != nil {
@@ -860,17 +903,19 @@
 // If allowIntersperse is set, arguments and flags can be interspersed, that
 // is flags can follow positional arguments.
 func Parse(allowIntersperse bool) {
-	// Ignore errors; commandLine is set for ExitOnError.
-	commandLine.Parse(allowIntersperse, os.Args[1:])
+	// Ignore errors; CommandLine is set for ExitOnError.
+	CommandLine.Parse(allowIntersperse, os.Args[1:])
 }
 
 // Parsed returns true if the command-line flags have been parsed.
 func Parsed() bool {
-	return commandLine.Parsed()
+	return CommandLine.Parsed()
 }
 
-// The default set of command-line flags, parsed from os.Args.
-var commandLine = NewFlagSet(os.Args[0], ExitOnError)
+// CommandLine is the default set of command-line flags, parsed from os.Args.
+// The top-level functions such as BoolVar, Arg, and so on are wrappers for the
+// methods of CommandLine.
+var CommandLine = NewFlagSet(os.Args[0], ExitOnError)
 
 // NewFlagSet returns a new, empty flag set with the specified name and
 // error handling property.

=== modified file 'flag_test.go'
--- flag_test.go	2012-10-02 13:48:04 +0000
+++ flag_test.go	2015-01-26 18:18:29 +0000
@@ -94,10 +94,54 @@
 	}
 }
 
+func TestGet(t *testing.T) {
+	ResetForTesting(nil)
+	Bool("test_bool", true, "bool value")
+	Int("test_int", 1, "int value")
+	Int64("test_int64", 2, "int64 value")
+	Uint("test_uint", 3, "uint value")
+	Uint64("test_uint64", 4, "uint64 value")
+	String("test_string", "5", "string value")
+	Float64("test_float64", 6, "float64 value")
+	Duration("test_duration", 7, "time.Duration value")
+
+	visitor := func(f *Flag) {
+		if len(f.Name) > 5 && f.Name[0:5] == "test_" {
+			g, ok := f.Value.(Getter)
+			if !ok {
+				t.Errorf("Visit: value does not satisfy Getter: %T", f.Value)
+				return
+			}
+			switch f.Name {
+			case "test_bool":
+				ok = g.Get() == true
+			case "test_int":
+				ok = g.Get() == int(1)
+			case "test_int64":
+				ok = g.Get() == int64(2)
+			case "test_uint":
+				ok = g.Get() == uint(3)
+			case "test_uint64":
+				ok = g.Get() == uint64(4)
+			case "test_string":
+				ok = g.Get() == "5"
+			case "test_float64":
+				ok = g.Get() == float64(6)
+			case "test_duration":
+				ok = g.Get() == time.Duration(7)
+			}
+			if !ok {
+				t.Errorf("Visit: bad value %T(%v) for %s", g.Get(), g.Get(), f.Name)
+			}
+		}
+	}
+	VisitAll(visitor)
+}
+
 func TestUsage(t *testing.T) {
 	called := false
 	ResetForTesting(func() { called = true })
-	f := CommandLine()
+	f := CommandLine
 	f.SetOutput(nullWriter{})
 	if f.Parse(true, []string{"-x"}) == nil {
 		t.Error("parse did not fail for unknown flag")
@@ -383,9 +427,8 @@
 func TestParse(t *testing.T) {
 	testParse(func() *FlagSet {
 		ResetForTesting(func() {})
-		f := CommandLine()
-		f.SetOutput(nullWriter{})
-		return f
+		CommandLine.SetOutput(nullWriter{})
+		return CommandLine
 	}, t)
 }
 
@@ -426,6 +469,57 @@
 	}
 }
 
+func TestUserDefinedForCommandLine(t *testing.T) {
+	const help = "HELP"
+	var result string
+	ResetForTesting(func() { result = help })
+	Usage()
+	if result != help {
+		t.Fatalf("got %q; expected %q", result, help)
+	}
+}
+
+// Declare a user-defined boolean flag type.
+type boolFlagVar struct {
+	count int
+}
+
+func (b *boolFlagVar) String() string {
+	return fmt.Sprintf("%d", b.count)
+}
+
+func (b *boolFlagVar) Set(value string) error {
+	if value == "true" {
+		b.count++
+	}
+	return nil
+}
+
+func (b *boolFlagVar) IsBoolFlag() bool {
+	return b.count < 4
+}
+
+func TestUserDefinedBool(t *testing.T) {
+	var flags FlagSet
+	flags.Init("test", ContinueOnError)
+	var b boolFlagVar
+	var err error
+	flags.Var(&b, "b", "usage")
+	if err = flags.Parse(true, []string{"-b", "-b", "-b", "-b=true", "-b=false", "-b", "barg", "-b"}); err != nil {
+		if b.count < 4 {
+			t.Error(err)
+		}
+	}
+
+	if b.count != 4 {
+		t.Errorf("want: %d; got: %d", 4, b.count)
+	}
+
+	if err == nil {
+		t.Error("expected error; got none")
+	}
+}
+
 func TestSetOutput(t *testing.T) {
 	var flags FlagSet
 	var buf bytes.Buffer
@@ -445,7 +539,7 @@
 	defer func() { os.Args = oldArgs }()
 	os.Args = []string{"cmd", "--before", "subcmd", "--after", "args"}
 	before := Bool("before", false, "")
-	if err := CommandLine().Parse(false, os.Args[1:]); err != nil {
+	if err := CommandLine.Parse(false, os.Args[1:]); err != nil {
 		t.Fatal(err)
 	}
 	cmd := Arg(0)