Merge remote-tracking branch 'origin/main' into security-policy-doc

.github/workflows/cli.yml

@@ -37,12 +37,18 @@ jobs:
       - name: vet
         run: go run internal/build/build.go vet
 
+      - name: test with tags
+        run: go run internal/build/build.go -tags urfave_cli_no_docs test
+
       - name: test
         run: go run internal/build/build.go test
 
       - name: check-binary-size
         run: go run internal/build/build.go check-binary-size
 
+      - name: check-binary-size with tags (informational only)
+        run: go run internal/build/build.go -tags urfave_cli_no_docs check-binary-size || true
+
       - name: Upload coverage to Codecov
         if: success() && matrix.go == '1.18.x' && matrix.os == 'ubuntu-latest'
         uses: codecov/codecov-action@v2
@@ -81,3 +87,8 @@ jobs:
 
       - name: toc
         run: go run internal/build/build.go toc docs/v2/manual.md
+
+      - name: diff check
+        run: |
+          git diff --exit-code
+          git diff --cached --exit-code

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016 Jeremy Saenz & Contributors
+Copyright (c) 2022 urfave/cli maintainers
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Makefile

@@ -0,0 +1,32 @@
+# NOTE: this Makefile is meant to provide a simplified entry point for humans to
+# run all of the critical steps to verify one's changes are harmonious in
+# nature. Keeping target bodies to one line each and abstaining from make magic
+# are very important so that maintainers and contributors can focus their
+# attention on files that are primarily Go.
+
+.PHONY: all
+all: generate vet tag-test test check-binary-size tag-check-binary-size gfmrun toc v2diff
+
+# NOTE: this is a special catch-all rule to run any of the commands
+# defined in internal/build/build.go with optional arguments passed
+# via GFLAGS (global flags) and FLAGS (command-specific flags), e.g.:
+#
+#   $ make test GFLAGS='--packages cli'
+%:
+	go run internal/build/build.go $(GFLAGS) $* $(FLAGS)
+
+.PHONY: tag-test
+tag-test:
+	go run internal/build/build.go -tags urfave_cli_no_docs test
+
+.PHONY: tag-check-binary-size
+tag-check-binary-size:
+	go run internal/build/build.go -tags urfave_cli_no_docs check-binary-size
+
+.PHONY: gfmrun
+gfmrun:
+	go run internal/build/build.go gfmrun docs/v2/manual.md
+
+.PHONY: toc
+toc:
+	go run internal/build/build.go toc docs/v2/manual.md

README.md

@@ -55,6 +55,16 @@ import (
 ...
 ```
 
+### Build tags
+
+You can use the following build tags:
+
+#### `urfave_cli_no_docs`
+
+When set, this removes `ToMarkdown` and `ToMan` methods, so your application
+won't be able to call those. This reduces the resulting binary size by about
+300-400 KB (measured using Go 1.18.1 on Linux/amd64), due to less dependencies.
+
 ### GOPATH
 
 Make sure your `PATH` includes the `$GOPATH/bin` directory so your commands can
@@ -68,3 +78,7 @@ export PATH=$PATH:$GOPATH/bin
 cli is tested against multiple versions of Go on Linux, and against the latest
 released version of Go on OS X and Windows. This project uses Github Actions for
 builds. To see our currently supported go versions and platforms, look at the [./.github/workflows/cli.yml](https://github.com/urfave/cli/blob/main/.github/workflows/cli.yml).
+
+## License
+
+See [`LICENSE`](./LICENSE)

altsrc/flag.go

@@ -13,18 +13,18 @@ import (
 // allows a value to be set on the existing parsed flags.
 type FlagInputSourceExtension interface {
 	cli.Flag
-	ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error
+	ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error
 }
 
 // ApplyInputSourceValues iterates over all provided flags and
 // executes ApplyInputSourceValue on flags implementing the
 // FlagInputSourceExtension interface to initialize these flags
 // to an alternate input source.
-func ApplyInputSourceValues(context *cli.Context, inputSourceContext InputSourceContext, flags []cli.Flag) error {
+func ApplyInputSourceValues(cCtx *cli.Context, inputSourceContext InputSourceContext, flags []cli.Flag) error {
 	for _, f := range flags {
 		inputSourceExtendedFlag, isType := f.(FlagInputSourceExtension)
 		if isType {
-			err := inputSourceExtendedFlag.ApplyInputSourceValue(context, inputSourceContext)
+			err := inputSourceExtendedFlag.ApplyInputSourceValue(cCtx, inputSourceContext)
 			if err != nil {
 				return err
 			}
@@ -38,42 +38,40 @@ func ApplyInputSourceValues(context *cli.Context, inputSourceContext InputSource
 // input source based on the func provided. If there is no error it will then apply the new input source to any flags
 // that are supported by the input source
 func InitInputSource(flags []cli.Flag, createInputSource func() (InputSourceContext, error)) cli.BeforeFunc {
-	return func(context *cli.Context) error {
+	return func(cCtx *cli.Context) error {
 		inputSource, err := createInputSource()
 		if err != nil {
 			return fmt.Errorf("Unable to create input source: inner error: \n'%v'", err.Error())
 		}
 
-		return ApplyInputSourceValues(context, inputSource, flags)
+		return ApplyInputSourceValues(cCtx, inputSource, flags)
 	}
 }
 
 // InitInputSourceWithContext is used to to setup an InputSourceContext on a cli.Command Before method. It will create a new
 // input source based on the func provided with potentially using existing cli.Context values to initialize itself. If there is
 // no error it will then apply the new input source to any flags that are supported by the input source
-func InitInputSourceWithContext(flags []cli.Flag, createInputSource func(context *cli.Context) (InputSourceContext, error)) cli.BeforeFunc {
-	return func(context *cli.Context) error {
-		inputSource, err := createInputSource(context)
+func InitInputSourceWithContext(flags []cli.Flag, createInputSource func(cCtx *cli.Context) (InputSourceContext, error)) cli.BeforeFunc {
+	return func(cCtx *cli.Context) error {
+		inputSource, err := createInputSource(cCtx)
 		if err != nil {
 			return fmt.Errorf("Unable to create input source with context: inner error: \n'%v'", err.Error())
 		}
 
-		return ApplyInputSourceValues(context, inputSource, flags)
+		return ApplyInputSourceValues(cCtx, inputSource, flags)
 	}
 }
 
 // ApplyInputSourceValue applies a generic value to the flagSet if required
-func (f *GenericFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
-			value, err := isc.Generic(f.GenericFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value != nil {
-				for _, name := range f.Names() {
-					_ = f.set.Set(name, value.String())
-				}
+func (f *GenericFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
+	if f.set != nil && !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) && isc.isSet(f.GenericFlag.Name) {
+		value, err := isc.Generic(f.GenericFlag.Name)
+		if err != nil {
+			return err
+		}
+		if value != nil {
+			for _, name := range f.Names() {
+				_ = f.set.Set(name, value.String())
 			}
 		}
 	}
@@ -82,20 +80,18 @@ func (f *GenericFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourc
 }
 
 // ApplyInputSourceValue applies a StringSlice value to the flagSet if required
-func (f *StringSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
-			value, err := isc.StringSlice(f.StringSliceFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value != nil {
-				var sliceValue cli.StringSlice = *(cli.NewStringSlice(value...))
-				for _, name := range f.Names() {
-					underlyingFlag := f.set.Lookup(name)
-					if underlyingFlag != nil {
-						underlyingFlag.Value = &sliceValue
-					}
+func (f *StringSliceFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
+	if f.set != nil && !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) && isc.isSet(f.StringSliceFlag.Name) {
+		value, err := isc.StringSlice(f.StringSliceFlag.Name)
+		if err != nil {
+			return err
+		}
+		if value != nil {
+			var sliceValue cli.StringSlice = *(cli.NewStringSlice(value...))
+			for _, name := range f.Names() {
+				underlyingFlag := f.set.Lookup(name)
+				if underlyingFlag != nil {
+					underlyingFlag.Value = &sliceValue
 				}
 			}
 		}
@@ -104,20 +100,18 @@ func (f *StringSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputS
 }
 
 // ApplyInputSourceValue applies a IntSlice value if required
-func (f *IntSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
-			value, err := isc.IntSlice(f.IntSliceFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value != nil {
-				var sliceValue cli.IntSlice = *(cli.NewIntSlice(value...))
-				for _, name := range f.Names() {
-					underlyingFlag := f.set.Lookup(name)
-					if underlyingFlag != nil {
-						underlyingFlag.Value = &sliceValue
-					}
+func (f *IntSliceFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
+	if f.set != nil && !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) && isc.isSet(f.IntSliceFlag.Name) {
+		value, err := isc.IntSlice(f.IntSliceFlag.Name)
+		if err != nil {
+			return err
+		}
+		if value != nil {
+			var sliceValue cli.IntSlice = *(cli.NewIntSlice(value...))
+			for _, name := range f.Names() {
+				underlyingFlag := f.set.Lookup(name)
+				if underlyingFlag != nil {
+					underlyingFlag.Value = &sliceValue
 				}
 			}
 		}
@@ -126,17 +120,15 @@ func (f *IntSliceFlag) ApplyInputSourceValue(context *cli.Context, isc InputSour
 }
 
 // ApplyInputSourceValue applies a Bool value to the flagSet if required
-func (f *BoolFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !context.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
-			value, err := isc.Bool(f.BoolFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value {
-				for _, name := range f.Names() {
-					_ = f.set.Set(name, strconv.FormatBool(value))
-				}
+func (f *BoolFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
+	if f.set != nil && !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) && isc.isSet(f.BoolFlag.Name) {
+		value, err := isc.Bool(f.BoolFlag.Name)
+		if err != nil {
+			return err
+		}
+		if value {
+			for _, name := range f.Names() {
+				_ = f.set.Set(name, strconv.FormatBool(value))
 			}
 		}
 	}
@@ -144,17 +136,15 @@ func (f *BoolFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceCo
 }
 
 // ApplyInputSourceValue applies a String value to the flagSet if required
-func (f *StringFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
-			value, err := isc.String(f.StringFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value != "" {
-				for _, name := range f.Names() {
-					_ = f.set.Set(name, value)
-				}
+func (f *StringFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
+	if f.set != nil && !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) && isc.isSet(f.StringFlag.Name) {
+		value, err := isc.String(f.StringFlag.Name)
+		if err != nil {
+			return err
+		}
+		if value != "" {
+			for _, name := range f.Names() {
+				_ = f.set.Set(name, value)
 			}
 		}
 	}
@@ -162,27 +152,25 @@ func (f *StringFlag) ApplyInputSourceValue(context *cli.Context, isc InputSource
 }
 
 // ApplyInputSourceValue applies a Path value to the flagSet if required
-func (f *PathFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
-			value, err := isc.String(f.PathFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value != "" {
-				for _, name := range f.Names() {
-
-					if !filepath.IsAbs(value) && isc.Source() != "" {
-						basePathAbs, err := filepath.Abs(isc.Source())
-						if err != nil {
-							return err
-						}
+func (f *PathFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
+	if f.set != nil && !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) && isc.isSet(f.PathFlag.Name) {
+		value, err := isc.String(f.PathFlag.Name)
+		if err != nil {
+			return err
+		}
+		if value != "" {
+			for _, name := range f.Names() {
 
-						value = filepath.Join(filepath.Dir(basePathAbs), value)
+				if !filepath.IsAbs(value) && isc.Source() != "" {
+					basePathAbs, err := filepath.Abs(isc.Source())
+					if err != nil {
+						return err
 					}
 
-					_ = f.set.Set(name, value)
+					value = filepath.Join(filepath.Dir(basePathAbs), value)
 				}
+
+				_ = f.set.Set(name, value)
 			}
 		}
 	}
@@ -190,55 +178,43 @@ func (f *PathFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceCo
 }
 
 // ApplyInputSourceValue applies a int value to the flagSet if required
-func (f *IntFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
-			value, err := isc.Int(f.IntFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value > 0 {
-				for _, name := range f.Names() {
-					_ = f.set.Set(name, strconv.FormatInt(int64(value), 10))
-				}
-			}
+func (f *IntFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
+	if f.set != nil && !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) && isc.isSet(f.IntFlag.Name) {
+		value, err := isc.Int(f.IntFlag.Name)
+		if err != nil {
+			return err
+		}
+		for _, name := range f.Names() {
+			_ = f.set.Set(name, strconv.FormatInt(int64(value), 10))
 		}
 	}
 	return nil
 }
 
 // ApplyInputSourceValue applies a Duration value to the flagSet if required
-func (f *DurationFlag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
-			value, err := isc.Duration(f.DurationFlag.Name)
-			if err != nil {
-				return err
-			}
-			if value > 0 {
-				for _, name := range f.Names() {
-					_ = f.set.Set(name, value.String())
-				}
-			}
+func (f *DurationFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
+	if f.set != nil && !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) && isc.isSet(f.DurationFlag.Name) {
+		value, err := isc.Duration(f.DurationFlag.Name)
+		if err != nil {
+			return err
+		}
+		for _, name := range f.Names() {
+			_ = f.set.Set(name, value.String())
 		}
 	}
 	return nil
 }
 
 // ApplyInputSourceValue applies a Float64 value to the flagSet if required
-func (f *Float64Flag) ApplyInputSourceValue(context *cli.Context, isc InputSourceContext) error {
-	if f.set != nil {
-		if !(context.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
-			value, err := isc.Float64(f.Float64Flag.Name)
-			if err != nil {
-				return err
-			}
-			if value > 0 {
-				floatStr := float64ToString(value)
-				for _, name := range f.Names() {
-					_ = f.set.Set(name, floatStr)
-				}
-			}
+func (f *Float64Flag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
+	if f.set != nil && !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) && isc.isSet(f.Float64Flag.Name) {
+		value, err := isc.Float64(f.Float64Flag.Name)
+		if err != nil {
+			return err
+		}
+		floatStr := float64ToString(value)
+		for _, name := range f.Names() {
+			_ = f.set.Set(name, floatStr)
 		}
 	}
 	return nil

altsrc/flag_test.go

@@ -26,29 +26,48 @@ type testApplyInputSource struct {
 	MapValue           interface{}
 }
 
+type racyInputSource struct {
+	*MapInputSource
+}
+
+func (ris *racyInputSource) isSet(name string) bool {
+	if _, ok := ris.MapInputSource.valueMap[name]; ok {
+		ris.MapInputSource.valueMap[name] = bogus{0}
+	}
+	return true
+}
+
 func TestGenericApplyInputSourceValue(t *testing.T) {
 	v := &Parser{"abc", "def"}
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:     NewGenericFlag(&cli.GenericFlag{Name: "test", Value: &Parser{}}),
 		FlagName: "test",
 		MapValue: v,
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, v, c.Generic("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, v, c.Generic("test"))
 }
 
 func TestGenericApplyInputSourceMethodContextSet(t *testing.T) {
 	p := &Parser{"abc", "def"}
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:               NewGenericFlag(&cli.GenericFlag{Name: "test", Value: &Parser{}}),
 		FlagName:           "test",
 		MapValue:           &Parser{"efg", "hig"},
 		ContextValueString: p.String(),
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, p, c.Generic("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, p, c.Generic("test"))
 }
 
 func TestGenericApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag: NewGenericFlag(&cli.GenericFlag{
 			Name:    "test",
 			Value:   &Parser{},
@@ -58,17 +77,25 @@ func TestGenericApplyInputSourceMethodEnvVarSet(t *testing.T) {
 		MapValue:    &Parser{"efg", "hij"},
 		EnvVarName:  "TEST",
 		EnvVarValue: "abc,def",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, &Parser{"abc", "def"}, c.Generic("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, &Parser{"abc", "def"}, c.Generic("test"))
 }
 
 func TestStringSliceApplyInputSourceValue(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:     NewStringSliceFlag(&cli.StringSliceFlag{Name: "test"}),
 		FlagName: "test",
 		MapValue: []interface{}{"hello", "world"},
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, c.StringSlice("test"), []string{"hello", "world"})
+
+	c = runRacyTest(t, tis)
+	refute(t, c.StringSlice("test"), []string{"hello", "world"})
 }
 
 func TestStringSliceApplyInputSourceMethodContextSet(t *testing.T) {
@@ -82,112 +109,154 @@ func TestStringSliceApplyInputSourceMethodContextSet(t *testing.T) {
 }
 
 func TestStringSliceApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:        NewStringSliceFlag(&cli.StringSliceFlag{Name: "test", EnvVars: []string{"TEST"}}),
 		FlagName:    "test",
 		MapValue:    []interface{}{"hello", "world"},
 		EnvVarName:  "TEST",
 		EnvVarValue: "oh,no",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, c.StringSlice("test"), []string{"oh", "no"})
+
+	c = runRacyTest(t, tis)
+	refute(t, c.StringSlice("test"), []string{"oh", "no"})
 }
 
 func TestIntSliceApplyInputSourceValue(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:     NewIntSliceFlag(&cli.IntSliceFlag{Name: "test"}),
 		FlagName: "test",
 		MapValue: []interface{}{1, 2},
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, c.IntSlice("test"), []int{1, 2})
+
+	c = runRacyTest(t, tis)
+	refute(t, c.IntSlice("test"), []int{1, 2})
 }
 
 func TestIntSliceApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:               NewIntSliceFlag(&cli.IntSliceFlag{Name: "test"}),
 		FlagName:           "test",
 		MapValue:           []interface{}{1, 2},
 		ContextValueString: "3",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, c.IntSlice("test"), []int{3})
+
+	c = runRacyTest(t, tis)
+	refute(t, c.IntSlice("test"), []int{3})
 }
 
 func TestIntSliceApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:        NewIntSliceFlag(&cli.IntSliceFlag{Name: "test", EnvVars: []string{"TEST"}}),
 		FlagName:    "test",
 		MapValue:    []interface{}{1, 2},
 		EnvVarName:  "TEST",
 		EnvVarValue: "3,4",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, c.IntSlice("test"), []int{3, 4})
+
+	c = runRacyTest(t, tis)
+	refute(t, c.IntSlice("test"), []int{3, 4})
 }
 
 func TestBoolApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:     NewBoolFlag(&cli.BoolFlag{Name: "test"}),
 		FlagName: "test",
 		MapValue: true,
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, true, c.Bool("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, true, c.Bool("test"))
 }
 
 func TestBoolApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:               NewBoolFlag(&cli.BoolFlag{Name: "test"}),
 		FlagName:           "test",
 		MapValue:           false,
 		ContextValueString: "true",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, true, c.Bool("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, true, c.Bool("test"))
 }
 
 func TestBoolApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:        NewBoolFlag(&cli.BoolFlag{Name: "test", EnvVars: []string{"TEST"}}),
 		FlagName:    "test",
 		MapValue:    false,
 		EnvVarName:  "TEST",
 		EnvVarValue: "true",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, true, c.Bool("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, true, c.Bool("test"))
 }
 
 func TestStringApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:     NewStringFlag(&cli.StringFlag{Name: "test"}),
 		FlagName: "test",
 		MapValue: "hello",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, "hello", c.String("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, "hello", c.String("test"))
 }
 
 func TestStringApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:               NewStringFlag(&cli.StringFlag{Name: "test"}),
 		FlagName:           "test",
 		MapValue:           "hello",
 		ContextValueString: "goodbye",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, "goodbye", c.String("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, "goodbye", c.String("test"))
 }
 
 func TestStringApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:        NewStringFlag(&cli.StringFlag{Name: "test", EnvVars: []string{"TEST"}}),
 		FlagName:    "test",
 		MapValue:    "hello",
 		EnvVarName:  "TEST",
 		EnvVarValue: "goodbye",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, "goodbye", c.String("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, "goodbye", c.String("test"))
 }
+
 func TestPathApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:       NewPathFlag(&cli.PathFlag{Name: "test"}),
 		FlagName:   "test",
 		MapValue:   "hello",
 		SourcePath: "/path/to/source/file",
-	})
+	}
+	c := runTest(t, tis)
 
 	expected := "/path/to/source/hello"
 	if runtime.GOOS == "windows" {
@@ -200,119 +269,214 @@ func TestPathApplyInputSourceMethodSet(t *testing.T) {
 		}
 	}
 	expect(t, expected, c.String("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, expected, c.String("test"))
 }
 
 func TestPathApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:               NewPathFlag(&cli.PathFlag{Name: "test"}),
 		FlagName:           "test",
 		MapValue:           "hello",
 		ContextValueString: "goodbye",
 		SourcePath:         "/path/to/source/file",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, "goodbye", c.String("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, "goodbye", c.String("test"))
 }
 
 func TestPathApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:        NewPathFlag(&cli.PathFlag{Name: "test", EnvVars: []string{"TEST"}}),
 		FlagName:    "test",
 		MapValue:    "hello",
 		EnvVarName:  "TEST",
 		EnvVarValue: "goodbye",
 		SourcePath:  "/path/to/source/file",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, "goodbye", c.String("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, "goodbye", c.String("test"))
 }
 
 func TestIntApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:     NewIntFlag(&cli.IntFlag{Name: "test"}),
 		FlagName: "test",
 		MapValue: 15,
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, 15, c.Int("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, 15, c.Int("test"))
+}
+
+func TestIntApplyInputSourceMethodSetNegativeValue(t *testing.T) {
+	tis := testApplyInputSource{
+		Flag:     NewIntFlag(&cli.IntFlag{Name: "test"}),
+		FlagName: "test",
+		MapValue: -1,
+	}
+	c := runTest(t, tis)
+	expect(t, -1, c.Int("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, -1, c.Int("test"))
 }
 
 func TestIntApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:               NewIntFlag(&cli.IntFlag{Name: "test"}),
 		FlagName:           "test",
 		MapValue:           15,
 		ContextValueString: "7",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, 7, c.Int("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, 7, c.Int("test"))
 }
 
 func TestIntApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:        NewIntFlag(&cli.IntFlag{Name: "test", EnvVars: []string{"TEST"}}),
 		FlagName:    "test",
 		MapValue:    15,
 		EnvVarName:  "TEST",
 		EnvVarValue: "12",
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, 12, c.Int("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, 12, c.Int("test"))
 }
 
 func TestDurationApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:     NewDurationFlag(&cli.DurationFlag{Name: "test"}),
 		FlagName: "test",
 		MapValue: 30 * time.Second,
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, 30*time.Second, c.Duration("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, 30*time.Second, c.Duration("test"))
+}
+
+func TestDurationApplyInputSourceMethodSetNegativeValue(t *testing.T) {
+	tis := testApplyInputSource{
+		Flag:     NewDurationFlag(&cli.DurationFlag{Name: "test"}),
+		FlagName: "test",
+		MapValue: -30 * time.Second,
+	}
+	c := runTest(t, tis)
+	expect(t, -30*time.Second, c.Duration("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, -30*time.Second, c.Duration("test"))
 }
 
 func TestDurationApplyInputSourceMethodContextSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:               NewDurationFlag(&cli.DurationFlag{Name: "test"}),
 		FlagName:           "test",
 		MapValue:           30 * time.Second,
 		ContextValueString: (15 * time.Second).String(),
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, 15*time.Second, c.Duration("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, 15*time.Second, c.Duration("test"))
 }
 
 func TestDurationApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:        NewDurationFlag(&cli.DurationFlag{Name: "test", EnvVars: []string{"TEST"}}),
 		FlagName:    "test",
 		MapValue:    30 * time.Second,
 		EnvVarName:  "TEST",
 		EnvVarValue: (15 * time.Second).String(),
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, 15*time.Second, c.Duration("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, 15*time.Second, c.Duration("test"))
 }
 
 func TestFloat64ApplyInputSourceMethodSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:     NewFloat64Flag(&cli.Float64Flag{Name: "test"}),
 		FlagName: "test",
 		MapValue: 1.3,
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, 1.3, c.Float64("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, 1.3, c.Float64("test"))
 }
 
-func TestFloat64ApplyInputSourceMethodContextSet(t *testing.T) {
+func TestFloat64ApplyInputSourceMethodSetNegativeValue(t *testing.T) {
+	tis := testApplyInputSource{
+		Flag:     NewFloat64Flag(&cli.Float64Flag{Name: "test"}),
+		FlagName: "test",
+		MapValue: -1.3,
+	}
+	c := runTest(t, tis)
+	expect(t, -1.3, c.Float64("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, -1.3, c.Float64("test"))
+}
+
+func TestFloat64ApplyInputSourceMethodSetNegativeValueNotSet(t *testing.T) {
 	c := runTest(t, testApplyInputSource{
+		Flag:     NewFloat64Flag(&cli.Float64Flag{Name: "test1"}),
+		FlagName: "test1",
+		// dont set map value
+	})
+	expect(t, 0.0, c.Float64("test1"))
+}
+
+func TestFloat64ApplyInputSourceMethodContextSet(t *testing.T) {
+	tis := testApplyInputSource{
 		Flag:               NewFloat64Flag(&cli.Float64Flag{Name: "test"}),
 		FlagName:           "test",
 		MapValue:           1.3,
 		ContextValueString: fmt.Sprintf("%v", 1.4),
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, 1.4, c.Float64("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, 1.4, c.Float64("test"))
 }
 
 func TestFloat64ApplyInputSourceMethodEnvVarSet(t *testing.T) {
-	c := runTest(t, testApplyInputSource{
+	tis := testApplyInputSource{
 		Flag:        NewFloat64Flag(&cli.Float64Flag{Name: "test", EnvVars: []string{"TEST"}}),
 		FlagName:    "test",
 		MapValue:    1.3,
 		EnvVarName:  "TEST",
 		EnvVarValue: fmt.Sprintf("%v", 1.4),
-	})
+	}
+	c := runTest(t, tis)
 	expect(t, 1.4, c.Float64("test"))
+
+	c = runRacyTest(t, tis)
+	refute(t, 1.4, c.Float64("test"))
 }
 
 func runTest(t *testing.T, test testApplyInputSource) *cli.Context {
@@ -340,6 +504,19 @@ func runTest(t *testing.T, test testApplyInputSource) *cli.Context {
 	return c
 }
 
+func runRacyTest(t *testing.T, test testApplyInputSource) *cli.Context {
+	set := flag.NewFlagSet(test.FlagSetName, flag.ContinueOnError)
+	c := cli.NewContext(nil, set, nil)
+	_ = test.Flag.ApplyInputSourceValue(c, &racyInputSource{
+		MapInputSource: &MapInputSource{
+			file:     test.SourcePath,
+			valueMap: map[interface{}]interface{}{test.FlagName: test.MapValue},
+		},
+	})
+
+	return c
+}
+
 type Parser [2]string
 
 func (p *Parser) Set(value string) error {
@@ -357,3 +534,5 @@ func (p *Parser) Set(value string) error {
 func (p *Parser) String() string {
 	return fmt.Sprintf("%s,%s", p[0], p[1])
 }
+
+type bogus [1]uint

altsrc/helpers_test.go

@@ -22,7 +22,10 @@ func expect(t *testing.T, a interface{}, b interface{}) {
 }
 
 func refute(t *testing.T, a interface{}, b interface{}) {
-	if a == b {
-		t.Errorf("Did not expect %v (type %v) - Got %v (type %v)", b, reflect.TypeOf(b), a, reflect.TypeOf(a))
+	_, fn, line, _ := runtime.Caller(1)
+	fn = strings.Replace(fn, wd+"/", "", -1)
+
+	if reflect.DeepEqual(a, b) {
+		t.Errorf("(%s:%d) Did not expect %v (type %v) - Got %v (type %v)", fn, line, b, reflect.TypeOf(b), a, reflect.TypeOf(a))
 	}
 }

altsrc/input_source_context.go

@@ -22,4 +22,6 @@ type InputSourceContext interface {
 	IntSlice(name string) ([]int, error)
 	Generic(name string) (cli.Generic, error)
 	Bool(name string) (bool, error)
+
+	isSet(name string) bool
 }

altsrc/json_source_context.go

@@ -16,9 +16,9 @@ import (
 // variables from a file containing JSON data with the file name defined
 // by the given flag.
 func NewJSONSourceFromFlagFunc(flag string) func(c *cli.Context) (InputSourceContext, error) {
-	return func(context *cli.Context) (InputSourceContext, error) {
-		if context.IsSet(flag) {
-			return NewJSONSourceFromFile(context.String(flag))
+	return func(cCtx *cli.Context) (InputSourceContext, error) {
+		if cCtx.IsSet(flag) {
+			return NewJSONSourceFromFile(cCtx.String(flag))
 		}
 
 		return defaultInputSource()
@@ -184,6 +184,11 @@ func (x *jsonSource) Bool(name string) (bool, error) {
 	return v, nil
 }
 
+func (x *jsonSource) isSet(name string) bool {
+	_, err := x.getValue(name)
+	return err == nil
+}
+
 func (x *jsonSource) getValue(key string) (interface{}, error) {
 	return jsonGetValue(key, x.deserialized)
 }

altsrc/map_input_source.go

@@ -244,6 +244,15 @@ func (fsm *MapInputSource) Bool(name string) (bool, error) {
 	return false, nil
 }
 
+func (fsm *MapInputSource) isSet(name string) bool {
+	if _, exists := fsm.valueMap[name]; exists {
+		return exists
+	}
+
+	_, exists := nestedVal(name, fsm.valueMap)
+	return exists
+}
+
 func incorrectTypeForFlagError(name, expectedTypeName string, value interface{}) error {
 	valueType := reflect.TypeOf(value)
 	valueTypeName := ""

altsrc/toml_file_loader.go

@@ -85,10 +85,10 @@ func NewTomlSourceFromFile(file string) (InputSourceContext, error) {
 }
 
 // NewTomlSourceFromFlagFunc creates a new TOML InputSourceContext from a provided flag name and source context.
-func NewTomlSourceFromFlagFunc(flagFileName string) func(context *cli.Context) (InputSourceContext, error) {
-	return func(context *cli.Context) (InputSourceContext, error) {
-		if context.IsSet(flagFileName) {
-			filePath := context.String(flagFileName)
+func NewTomlSourceFromFlagFunc(flagFileName string) func(cCtx *cli.Context) (InputSourceContext, error) {
+	return func(cCtx *cli.Context) (InputSourceContext, error) {
+		if cCtx.IsSet(flagFileName) {
+			filePath := cCtx.String(flagFileName)
 			return NewTomlSourceFromFile(filePath)
 		}
 

altsrc/yaml_file_loader.go

@@ -31,10 +31,10 @@ func NewYamlSourceFromFile(file string) (InputSourceContext, error) {
 }
 
 // NewYamlSourceFromFlagFunc creates a new Yaml InputSourceContext from a provided flag name and source context.
-func NewYamlSourceFromFlagFunc(flagFileName string) func(context *cli.Context) (InputSourceContext, error) {
-	return func(context *cli.Context) (InputSourceContext, error) {
-		if context.IsSet(flagFileName) {
-			filePath := context.String(flagFileName)
+func NewYamlSourceFromFlagFunc(flagFileName string) func(cCtx *cli.Context) (InputSourceContext, error) {
+	return func(cCtx *cli.Context) (InputSourceContext, error) {
+		if cCtx.IsSet(flagFileName) {
+			filePath := cCtx.String(flagFileName)
 			return NewYamlSourceFromFile(filePath)
 		}
 

altsrc/yaml_file_loader_test.go

@@ -0,0 +1,87 @@
+package altsrc_test
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"time"
+
+	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v2/altsrc"
+)
+
+func ExampleApp_Run_yamlFileLoaderDuration() {
+	execServe := func(c *cli.Context) error {
+		keepaliveInterval := c.Duration("keepalive-interval")
+		fmt.Printf("keepalive %s\n", keepaliveInterval)
+		return nil
+	}
+
+	fileExists := func(filename string) bool {
+		stat, _ := os.Stat(filename)
+		return stat != nil
+	}
+
+	// initConfigFileInputSource is like altsrc.InitInputSourceWithContext and altsrc.NewYamlSourceFromFlagFunc, but checks
+	// if the config flag is exists and only loads it if it does. If the flag is set and the file exists, it fails.
+	initConfigFileInputSource := func(configFlag string, flags []cli.Flag) cli.BeforeFunc {
+		return func(context *cli.Context) error {
+			configFile := context.String(configFlag)
+			if context.IsSet(configFlag) && !fileExists(configFile) {
+				return fmt.Errorf("config file %s does not exist", configFile)
+			} else if !context.IsSet(configFlag) && !fileExists(configFile) {
+				return nil
+			}
+			inputSource, err := altsrc.NewYamlSourceFromFile(configFile)
+			if err != nil {
+				return err
+			}
+			return altsrc.ApplyInputSourceValues(context, inputSource, flags)
+		}
+	}
+
+	flagsServe := []cli.Flag{
+		&cli.StringFlag{
+			Name:        "config",
+			Aliases:     []string{"c"},
+			EnvVars:     []string{"CONFIG_FILE"},
+			Value:       "../testdata/empty.yml",
+			DefaultText: "../testdata/empty.yml",
+			Usage:       "config file",
+		},
+		altsrc.NewDurationFlag(
+			&cli.DurationFlag{
+				Name:    "keepalive-interval",
+				Aliases: []string{"k"},
+				EnvVars: []string{"KEEPALIVE_INTERVAL"},
+				Value:   45 * time.Second,
+				Usage:   "interval of keepalive messages",
+			},
+		),
+	}
+
+	cmdServe := &cli.Command{
+		Name:      "serve",
+		Usage:     "Run the server",
+		UsageText: "serve [OPTIONS..]",
+		Action:    execServe,
+		Flags:     flagsServe,
+		Before:    initConfigFileInputSource("config", flagsServe),
+	}
+
+	c := &cli.App{
+		Name:                   "cmd",
+		HideVersion:            true,
+		UseShortOptionHandling: true,
+		Commands: []*cli.Command{
+			cmdServe,
+		},
+	}
+
+	if err := c.Run([]string{"cmd", "serve", "--config", "../testdata/empty.yml"}); err != nil {
+		log.Fatal(err)
+	}
+
+	// Output:
+	// keepalive 45s
+}

app.go

@@ -245,48 +245,48 @@ func (a *App) RunContext(ctx context.Context, arguments []string) (err error) {
 
 	err = parseIter(set, a, arguments[1:], shellComplete)
 	nerr := normalizeFlags(a.Flags, set)
-	context := NewContext(a, set, &Context{Context: ctx})
+	cCtx := NewContext(a, set, &Context{Context: ctx})
 	if nerr != nil {
 		_, _ = fmt.Fprintln(a.Writer, nerr)
-		_ = ShowAppHelp(context)
+		_ = ShowAppHelp(cCtx)
 		return nerr
 	}
-	context.shellComplete = shellComplete
+	cCtx.shellComplete = shellComplete
 
-	if checkCompletions(context) {
+	if checkCompletions(cCtx) {
 		return nil
 	}
 
 	if err != nil {
 		if a.OnUsageError != nil {
-			err := a.OnUsageError(context, err, false)
-			a.handleExitCoder(context, err)
+			err := a.OnUsageError(cCtx, err, false)
+			a.handleExitCoder(cCtx, err)
 			return err
 		}
 		_, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
-		_ = ShowAppHelp(context)
+		_ = ShowAppHelp(cCtx)
 		return err
 	}
 
-	if !a.HideHelp && checkHelp(context) {
-		_ = ShowAppHelp(context)
+	if !a.HideHelp && checkHelp(cCtx) {
+		_ = ShowAppHelp(cCtx)
 		return nil
 	}
 
-	if !a.HideVersion && checkVersion(context) {
-		ShowVersion(context)
+	if !a.HideVersion && checkVersion(cCtx) {
+		ShowVersion(cCtx)
 		return nil
 	}
 
-	cerr := context.checkRequiredFlags(a.Flags)
+	cerr := cCtx.checkRequiredFlags(a.Flags)
 	if cerr != nil {
-		_ = ShowAppHelp(context)
+		_ = ShowAppHelp(cCtx)
 		return cerr
 	}
 
 	if a.After != nil {
 		defer func() {
-			if afterErr := a.After(context); afterErr != nil {
+			if afterErr := a.After(cCtx); afterErr != nil {
 				if err != nil {
 					err = newMultiError(err, afterErr)
 				} else {
@@ -297,20 +297,20 @@ func (a *App) RunContext(ctx context.Context, arguments []string) (err error) {
 	}
 
 	if a.Before != nil {
-		beforeErr := a.Before(context)
+		beforeErr := a.Before(cCtx)
 		if beforeErr != nil {
-			a.handleExitCoder(context, beforeErr)
+			a.handleExitCoder(cCtx, beforeErr)
 			err = beforeErr
 			return err
 		}
 	}
 
-	args := context.Args()
+	args := cCtx.Args()
 	if args.Present() {
 		name := args.First()
 		c := a.Command(name)
 		if c != nil {
-			return c.Run(context)
+			return c.Run(cCtx)
 		}
 	}
 
@@ -319,9 +319,9 @@ func (a *App) RunContext(ctx context.Context, arguments []string) (err error) {
 	}
 
 	// Run default Action
-	err = a.Action(context)
+	err = a.Action(cCtx)
 
-	a.handleExitCoder(context, err)
+	a.handleExitCoder(cCtx, err)
 	return err
 }
 
@@ -359,55 +359,55 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 
 	err = parseIter(set, a, ctx.Args().Tail(), ctx.shellComplete)
 	nerr := normalizeFlags(a.Flags, set)
-	context := NewContext(a, set, ctx)
+	cCtx := NewContext(a, set, ctx)
 
 	if nerr != nil {
 		_, _ = fmt.Fprintln(a.Writer, nerr)
 		_, _ = fmt.Fprintln(a.Writer)
 		if len(a.Commands) > 0 {
-			_ = ShowSubcommandHelp(context)
+			_ = ShowSubcommandHelp(cCtx)
 		} else {
-			_ = ShowCommandHelp(ctx, context.Args().First())
+			_ = ShowCommandHelp(ctx, cCtx.Args().First())
 		}
 		return nerr
 	}
 
-	if checkCompletions(context) {
+	if checkCompletions(cCtx) {
 		return nil
 	}
 
 	if err != nil {
 		if a.OnUsageError != nil {
-			err = a.OnUsageError(context, err, true)
-			a.handleExitCoder(context, err)
+			err = a.OnUsageError(cCtx, err, true)
+			a.handleExitCoder(cCtx, err)
 			return err
 		}
 		_, _ = fmt.Fprintf(a.Writer, "%s %s\n\n", "Incorrect Usage.", err.Error())
-		_ = ShowSubcommandHelp(context)
+		_ = ShowSubcommandHelp(cCtx)
 		return err
 	}
 
 	if len(a.Commands) > 0 {
-		if checkSubcommandHelp(context) {
+		if checkSubcommandHelp(cCtx) {
 			return nil
 		}
 	} else {
-		if checkCommandHelp(ctx, context.Args().First()) {
+		if checkCommandHelp(ctx, cCtx.Args().First()) {
 			return nil
 		}
 	}
 
-	cerr := context.checkRequiredFlags(a.Flags)
+	cerr := cCtx.checkRequiredFlags(a.Flags)
 	if cerr != nil {
-		_ = ShowSubcommandHelp(context)
+		_ = ShowSubcommandHelp(cCtx)
 		return cerr
 	}
 
 	if a.After != nil {
 		defer func() {
-			afterErr := a.After(context)
+			afterErr := a.After(cCtx)
 			if afterErr != nil {
-				a.handleExitCoder(context, err)
+				a.handleExitCoder(cCtx, err)
 				if err != nil {
 					err = newMultiError(err, afterErr)
 				} else {
@@ -418,27 +418,27 @@ func (a *App) RunAsSubcommand(ctx *Context) (err error) {
 	}
 
 	if a.Before != nil {
-		beforeErr := a.Before(context)
+		beforeErr := a.Before(cCtx)
 		if beforeErr != nil {
-			a.handleExitCoder(context, beforeErr)
+			a.handleExitCoder(cCtx, beforeErr)
 			err = beforeErr
 			return err
 		}
 	}
 
-	args := context.Args()
+	args := cCtx.Args()
 	if args.Present() {
 		name := args.First()
 		c := a.Command(name)
 		if c != nil {
-			return c.Run(context)
+			return c.Run(cCtx)
 		}
 	}
 
 	// Run default Action
-	err = a.Action(context)
+	err = a.Action(cCtx)
 
-	a.handleExitCoder(context, err)
+	a.handleExitCoder(cCtx, err)
 	return err
 }
 
@@ -498,9 +498,9 @@ func (a *App) appendCommand(c *Command) {
 	}
 }
 
-func (a *App) handleExitCoder(context *Context, err error) {
+func (a *App) handleExitCoder(cCtx *Context, err error) {
 	if a.ExitErrHandler != nil {
-		a.ExitErrHandler(context, err)
+		a.ExitErrHandler(cCtx, err)
 	} else {
 		HandleExitCoder(err)
 	}
@@ -525,14 +525,14 @@ func (a *Author) String() string {
 // HandleAction attempts to figure out which Action signature was used.  If
 // it's an ActionFunc or a func with the legacy signature for Action, the func
 // is run!
-func HandleAction(action interface{}, context *Context) (err error) {
+func HandleAction(action interface{}, cCtx *Context) (err error) {
 	switch a := action.(type) {
 	case ActionFunc:
-		return a(context)
+		return a(cCtx)
 	case func(*Context) error:
-		return a(context)
+		return a(cCtx)
 	case func(*Context): // deprecated function signature
-		a(context)
+		a(cCtx)
 		return nil
 	}
 

app_test.go

@@ -390,6 +390,40 @@ func ExampleApp_Run_zshComplete() {
 	// h:Shows a list of commands or help for one command
 }
 
+func ExampleApp_Run_sliceValues() {
+	// set args for examples sake
+	os.Args = []string{"multi_values",
+		"--stringSclice", "parsed1,parsed2", "--stringSclice", "parsed3,parsed4",
+		"--float64Sclice", "13.3,14.4", "--float64Sclice", "15.5,16.6",
+		"--int64Sclice", "13,14", "--int64Sclice", "15,16",
+		"--intSclice", "13,14", "--intSclice", "15,16",
+	}
+	app := NewApp()
+	app.Name = "multi_values"
+	app.Flags = []Flag{
+		&StringSliceFlag{Name: "stringSclice"},
+		&Float64SliceFlag{Name: "float64Sclice"},
+		&Int64SliceFlag{Name: "int64Sclice"},
+		&IntSliceFlag{Name: "intSclice"},
+	}
+	app.Action = func(ctx *Context) error {
+		for i, v := range ctx.FlagNames() {
+			fmt.Printf("%d-%s %#v\n", i, v, ctx.Value(v))
+		}
+		err := ctx.Err()
+		fmt.Println("error:", err)
+		return err
+	}
+
+	_ = app.Run(os.Args)
+	// Output:
+	// 0-float64Sclice cli.Float64Slice{slice:[]float64{13.3, 14.4, 15.5, 16.6}, hasBeenSet:true}
+	// 1-int64Sclice cli.Int64Slice{slice:[]int64{13, 14, 15, 16}, hasBeenSet:true}
+	// 2-intSclice cli.IntSlice{slice:[]int{13, 14, 15, 16}, hasBeenSet:true}
+	// 3-stringSclice cli.StringSlice{slice:[]string{"parsed1", "parsed2", "parsed3", "parsed4"}, hasBeenSet:true}
+	// error: <nil>
+}
+
 func TestApp_Run(t *testing.T) {
 	s := ""
 
@@ -445,14 +479,14 @@ func TestApp_Setup_defaultsWriter(t *testing.T) {
 }
 
 func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
-	var context *Context
+	var cCtx *Context
 
 	a := &App{
 		Commands: []*Command{
 			{
 				Name: "foo",
 				Action: func(c *Context) error {
-					context = c
+					cCtx = c
 					return nil
 				},
 				Flags: []Flag{
@@ -468,8 +502,8 @@ func TestApp_RunAsSubcommandParseFlags(t *testing.T) {
 	}
 	_ = a.Run([]string{"", "foo", "--lang", "spanish", "abcd"})
 
-	expect(t, context.Args().Get(0), "abcd")
-	expect(t, context.String("lang"), "spanish")
+	expect(t, cCtx.Args().Get(0), "abcd")
+	expect(t, cCtx.String("lang"), "spanish")
 }
 
 func TestApp_RunAsSubCommandIncorrectUsage(t *testing.T) {

cli.go

@@ -20,4 +20,4 @@
 //   }
 package cli
 
-//go:generate go run flag-gen/main.go flag-gen/assets_vfsdata.go
+//go:generate go run internal/genflags/cmd/genflags/main.go

command.go

@@ -105,39 +105,39 @@ func (c *Command) Run(ctx *Context) (err error) {
 
 	set, err := c.parseFlags(ctx.Args(), ctx.shellComplete)
 
-	context := NewContext(ctx.App, set, ctx)
-	context.Command = c
-	if checkCommandCompletions(context, c.Name) {
+	cCtx := NewContext(ctx.App, set, ctx)
+	cCtx.Command = c
+	if checkCommandCompletions(cCtx, c.Name) {
 		return nil
 	}
 
 	if err != nil {
 		if c.OnUsageError != nil {
-			err = c.OnUsageError(context, err, false)
-			context.App.handleExitCoder(context, err)
+			err = c.OnUsageError(cCtx, err, false)
+			cCtx.App.handleExitCoder(cCtx, err)
 			return err
 		}
-		_, _ = fmt.Fprintln(context.App.Writer, "Incorrect Usage:", err.Error())
-		_, _ = fmt.Fprintln(context.App.Writer)
-		_ = ShowCommandHelp(context, c.Name)
+		_, _ = fmt.Fprintln(cCtx.App.Writer, "Incorrect Usage:", err.Error())
+		_, _ = fmt.Fprintln(cCtx.App.Writer)
+		_ = ShowCommandHelp(cCtx, c.Name)
 		return err
 	}
 
-	if checkCommandHelp(context, c.Name) {
+	if checkCommandHelp(cCtx, c.Name) {
 		return nil
 	}
 
-	cerr := context.checkRequiredFlags(c.Flags)
+	cerr := cCtx.checkRequiredFlags(c.Flags)
 	if cerr != nil {
-		_ = ShowCommandHelp(context, c.Name)
+		_ = ShowCommandHelp(cCtx, c.Name)
 		return cerr
 	}
 
 	if c.After != nil {
 		defer func() {
-			afterErr := c.After(context)
+			afterErr := c.After(cCtx)
 			if afterErr != nil {
-				context.App.handleExitCoder(context, err)
+				cCtx.App.handleExitCoder(cCtx, err)
 				if err != nil {
 					err = newMultiError(err, afterErr)
 				} else {
@@ -148,9 +148,9 @@ func (c *Command) Run(ctx *Context) (err error) {
 	}
 
 	if c.Before != nil {
-		err = c.Before(context)
+		err = c.Before(cCtx)
 		if err != nil {
-			context.App.handleExitCoder(context, err)
+			cCtx.App.handleExitCoder(cCtx, err)
 			return err
 		}
 	}
@@ -159,11 +159,11 @@ func (c *Command) Run(ctx *Context) (err error) {
 		c.Action = helpSubcommand.Action
 	}
 
-	context.Command = c
-	err = c.Action(context)
+	cCtx.Command = c
+	err = c.Action(cCtx)
 
 	if err != nil {
-		context.App.handleExitCoder(context, err)
+		cCtx.App.handleExitCoder(cCtx, err)
 	}
 	return err
 }

command_test.go

@@ -30,7 +30,7 @@ func TestCommandFlagParsing(t *testing.T) {
 		set := flag.NewFlagSet("test", 0)
 		_ = set.Parse(c.testArgs)
 
-		context := NewContext(app, set, nil)
+		cCtx := NewContext(app, set, nil)
 
 		command := Command{
 			Name:            "test-cmd",
@@ -41,10 +41,10 @@ func TestCommandFlagParsing(t *testing.T) {
 			SkipFlagParsing: c.skipFlagParsing,
 		}
 
-		err := command.Run(context)
+		err := command.Run(cCtx)
 
 		expect(t, err, c.expectedErr)
-		expect(t, context.Args().Slice(), c.testArgs)
+		expect(t, cCtx.Args().Slice(), c.testArgs)
 	}
 }
 

context.go

@@ -40,18 +40,18 @@ func NewContext(app *App, set *flag.FlagSet, parentCtx *Context) *Context {
 }
 
 // NumFlags returns the number of flags set
-func (c *Context) NumFlags() int {
-	return c.flagSet.NFlag()
+func (cCtx *Context) NumFlags() int {
+	return cCtx.flagSet.NFlag()
 }
 
 // Set sets a context flag to a value.
-func (c *Context) Set(name, value string) error {
-	return c.flagSet.Set(name, value)
+func (cCtx *Context) Set(name, value string) error {
+	return cCtx.flagSet.Set(name, value)
 }
 
 // IsSet determines if the flag was actually set
-func (c *Context) IsSet(name string) bool {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) IsSet(name string) bool {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		isSet := false
 		fs.Visit(func(f *flag.Flag) {
 			if f.Name == name {
@@ -62,7 +62,7 @@ func (c *Context) IsSet(name string) bool {
 			return true
 		}
 
-		f := c.lookupFlag(name)
+		f := cCtx.lookupFlag(name)
 		if f == nil {
 			return false
 		}
@@ -74,28 +74,28 @@ func (c *Context) IsSet(name string) bool {
 }
 
 // LocalFlagNames returns a slice of flag names used in this context.
-func (c *Context) LocalFlagNames() []string {
+func (cCtx *Context) LocalFlagNames() []string {
 	var names []string
-	c.flagSet.Visit(makeFlagNameVisitor(&names))
+	cCtx.flagSet.Visit(makeFlagNameVisitor(&names))
 	return names
 }
 
 // FlagNames returns a slice of flag names used by the this context and all of
 // its parent contexts.
-func (c *Context) FlagNames() []string {
+func (cCtx *Context) FlagNames() []string {
 	var names []string
-	for _, ctx := range c.Lineage() {
-		ctx.flagSet.Visit(makeFlagNameVisitor(&names))
+	for _, pCtx := range cCtx.Lineage() {
+		pCtx.flagSet.Visit(makeFlagNameVisitor(&names))
 	}
 	return names
 }
 
 // Lineage returns *this* context and all of its ancestor contexts in order from
 // child to parent
-func (c *Context) Lineage() []*Context {
+func (cCtx *Context) Lineage() []*Context {
 	var lineage []*Context
 
-	for cur := c; cur != nil; cur = cur.parentContext {
+	for cur := cCtx; cur != nil; cur = cur.parentContext {
 		lineage = append(lineage, cur)
 	}
 
@@ -103,26 +103,26 @@ func (c *Context) Lineage() []*Context {
 }
 
 // Value returns the value of the flag corresponding to `name`
-func (c *Context) Value(name string) interface{} {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Value(name string) interface{} {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return fs.Lookup(name).Value.(flag.Getter).Get()
 	}
 	return nil
 }
 
 // Args returns the command line arguments associated with the context.
-func (c *Context) Args() Args {
-	ret := args(c.flagSet.Args())
+func (cCtx *Context) Args() Args {
+	ret := args(cCtx.flagSet.Args())
 	return &ret
 }
 
 // NArg returns the number of the command line arguments.
-func (c *Context) NArg() int {
-	return c.Args().Len()
+func (cCtx *Context) NArg() int {
+	return cCtx.Args().Len()
 }
 
-func (ctx *Context) lookupFlag(name string) Flag {
-	for _, c := range ctx.Lineage() {
+func (cCtx *Context) lookupFlag(name string) Flag {
+	for _, c := range cCtx.Lineage() {
 		if c.Command == nil {
 			continue
 		}
@@ -136,8 +136,8 @@ func (ctx *Context) lookupFlag(name string) Flag {
 		}
 	}
 
-	if ctx.App != nil {
-		for _, f := range ctx.App.Flags {
+	if cCtx.App != nil {
+		for _, f := range cCtx.App.Flags {
 			for _, n := range f.Names() {
 				if n == name {
 					return f
@@ -149,8 +149,8 @@ func (ctx *Context) lookupFlag(name string) Flag {
 	return nil
 }
 
-func (ctx *Context) lookupFlagSet(name string) *flag.FlagSet {
-	for _, c := range ctx.Lineage() {
+func (cCtx *Context) lookupFlagSet(name string) *flag.FlagSet {
+	for _, c := range cCtx.Lineage() {
 		if c.flagSet == nil {
 			continue
 		}
@@ -162,7 +162,7 @@ func (ctx *Context) lookupFlagSet(name string) *flag.FlagSet {
 	return nil
 }
 
-func (context *Context) checkRequiredFlags(flags []Flag) requiredFlagsErr {
+func (cCtx *Context) checkRequiredFlags(flags []Flag) requiredFlagsErr {
 	var missingFlags []string
 	for _, f := range flags {
 		if rf, ok := f.(RequiredFlag); ok && rf.IsRequired() {
@@ -174,7 +174,7 @@ func (context *Context) checkRequiredFlags(flags []Flag) requiredFlagsErr {
 					flagName = key
 				}
 
-				if context.IsSet(strings.TrimSpace(key)) {
+				if cCtx.IsSet(strings.TrimSpace(key)) {
 					flagPresent = true
 				}
 			}

docs.go

@@ -1,3 +1,6 @@
+//go:build !urfave_cli_no_docs
+// +build !urfave_cli_no_docs
+
 package cli
 
 import (
@@ -80,14 +83,14 @@ func prepareCommands(commands []*Command, level int) []string {
 			usageText,
 		)
 
-		flags := prepareArgsWithValues(command.Flags)
+		flags := prepareArgsWithValues(command.VisibleFlags())
 		if len(flags) > 0 {
 			prepared += fmt.Sprintf("\n%s", strings.Join(flags, "\n"))
 		}
 
 		coms = append(coms, prepared)
 
-		// recursevly iterate subcommands
+		// recursively iterate subcommands
 		if len(command.Subcommands) > 0 {
 			coms = append(
 				coms,

docs/CHANGELOG.md

@@ -1,3 +1,9 @@
+> :warning: This document is no longer being actively maintained. Please see the
+> [releases page](https://github.com/urfave/cli/releases) for all release notes
+> and related hypermedia for releases `>= 1.22.5`, `>= 2.3.0`.
+
+---
+
 # Change Log
 
 **ATTN**: This project uses [semantic versioning](http://semver.org/).

docs/CONTRIBUTING.md

@@ -1,18 +1,121 @@
 ## Contributing
 
-Use @urfave/cli to ping the maintainers.
-
-Feel free to put up a pull request to fix a bug or maybe add a feature. We will
-give it a code review and make sure that it does not break backwards
-compatibility. If collaborators agree that it is in line with
-the vision of the project, we will work with you to get the code into
-a mergeable state and merge it into the main branch.
-
-If you have contributed something significant to the project, we will most
-likely add you as a collaborator. As a collaborator you are given the ability
-to merge others pull requests. It is very important that new code does not
-break existing code, so be careful about what code you do choose to merge.
-
-If you feel like you have contributed to the project but have not yet been added
-as a collaborator, we probably forgot to add you :sweat_smile:. Please open an
-issue!
+Welcome to the `urfave/cli` contributor docs! This goal of this document is to help those
+interested in joining the 200+ humans who have contributed to this project over the years.
+
+> As a general guiding principle, the current maintainers may be notified via the
+> @urfave/cli GitHub team.
+
+All of the current maintainers are *volunteers* who live in various timezones with
+different scheduling needs, so please understand that your contribution or question may
+not get a response for many days.
+
+### semantic versioning adherence
+
+The `urfave/cli` project strives to strictly adhere to [semantic
+versioning](https://semver.org/spec/v2.0.0.html). The active development branches and the
+milestones and import paths to which they correspond are:
+
+#### `main` branch
+
+<https://github.com/urfave/cli/tree/main>
+
+The majority of active development and issue management is targeting the `main` branch,
+which **MUST** *only* receive bug fixes and feature *additions*.
+
+- :arrow_right: [`v2.x`](https://github.com/urfave/cli/milestone/16)
+- :arrow_right: `github.com/urfave/cli/v2`
+
+The `main` branch in particular includes tooling to help with keeping the `v2.x` series
+backward compatible. More details on this process are in the development workflow section
+below.
+
+#### `v1` branch
+
+<https://github.com/urfave/cli/tree/v1>
+
+The `v1` branch **MUST** only receive bug fixes in the `v1.22.x` series. There is no
+strict rule regarding bug fixes to the `v2.x` series being backported to the `v1.22.x`
+series.
+
+- :arrow_right: [`v1.22.x`](https://github.com/urfave/cli/milestone/11)
+- :arrow_right: `github.com/urfave/cli`
+
+#### `v3-dev-main` branch
+
+<https://github.com/urfave/cli/tree/v3-dev-main>
+
+The `v3-dev-branch` **MUST** receive all bug fixes and features added to the `main` branch
+and **MAY** receive feature *removals* and other changes that are otherwise
+*backward-incompatible* with the `v2.x` series.
+
+- :arrow_right: [`v3.x`](https://github.com/urfave/cli/milestone/5)
+- unreleased / unsupported
+
+### development workflow
+
+Most of the tooling around the development workflow strives for effective
+[dogfooding](https://en.wikipedia.org/wiki/Eating_your_own_dog_food). There is a top-level
+`Makefile` that is maintained strictly for the purpose of easing verification of one's
+development environment and any changes one may have introduced:
+
+```sh
+make
+```
+
+Running the default `make` target (`all`) will ensure all of the critical steps are run to
+verify one's changes are harmonious in nature. The same steps are also run during the
+[continuous integration
+phase](https://github.com/urfave/cli/blob/main/.github/workflows/cli.yml).
+
+In the event that the `v2diff` target exits non-zero, this is a signal that the public API
+surface area has changed. If the changes adhere to semantic versioning, meaning they are
+*additions* or *bug fixes*, then manually running the approval step will "promote" the
+current `go doc` output:
+
+```sh
+make v2approve
+```
+
+Because the `generate` step includes updating `godoc-current.txt` and
+`testdata/godoc-v2.x.txt`, these changes *MUST* be part of any proposed pull request so
+that reviewers have an opportunity to also make an informed decision about the "promotion"
+step.
+
+#### generated code
+
+A significant portion of the project's source code is generated, with the goal being to
+eliminate repetetive maintenance where other type-safe abstraction is impractical or
+impossible with Go versions `< 1.18`. In a future where the eldest Go version supported is
+`1.18.x`, there will likely be efforts to take advantage of
+[generics](https://go.dev/doc/tutorial/generics).
+
+The built-in `go generate` command is used to run the commands specified in
+`//go:generate` directives. Each such command runs a file that also supports a command
+line help system which may be consulted for further information, e.g.:
+
+```sh
+go run internal/genflags/cmd/genflags/main.go --help
+```
+
+### pull requests
+
+Please feel free to open a pull request to fix a bug or add a feature. The @urfave/cli
+team will review it as soon as possible, giving special attention to maintaining backward
+compatibility. If the @urfave/cli team agrees that your contribution is in line with the
+vision of the project, they will work with you to get the code into a mergeable state,
+merged, and then released.
+
+### granting of commit bit / admin mode
+
+Those with a history of contributing to this project will likely be invited to join the
+@urfave/cli team. As a member of the @urfave/cli team, you will have the ability to fully
+administer pull requests, issues, and other repository bits.
+
+If you feel that you should be a member of the @urfave/cli team but have not yet been
+added, the most likely explanation is that this is an accidental oversight! :sweat_smile:.
+Please open an issue!
+
+<!--
+vim:tw=90
+-->

docs/RELEASING.md

@@ -0,0 +1,61 @@
+# Releasing urfave/cli
+
+Releasing small batches often is [backed by
+research](https://itrevolution.com/accelerate-book/) as part of the
+virtuous cycles that keep teams and products healthy.
+
+To that end, the overall goal of the release process is to send
+changes out into the world as close to the time the commits were
+merged to the `main` branch as possible. In this way, the community
+of humans depending on this library are able to make use of the
+changes they need **quickly**, which means they shouldn't have to
+maintain long-lived forks of the project, which means they can get
+back to focusing on the work on which they want to focus. This also
+means that the @urfave/cli team should be able to focus on
+delivering a steadily improving product with significantly eased
+ability to associate bugs and regressions with specific releases.
+
+## Process
+
+- Release versions follow [semantic versioning](https://semver.org/)
+- Releases are associated with **signed, annotated git tags**[^1].
+- Release notes are **automatically generated**[^2].
+
+In the `main` or `v1` branch, the current version is always
+available via:
+
+```sh
+git describe --always --dirty --tags
+```
+
+**NOTE**: if the version reported contains `-dirty`, this is
+indicative of a "dirty" work tree, which is not a great state for
+creating a new release tag. Seek help from @urfave/cli teammates.
+
+For example, given a described version of `v2.4.7-3-g68da1cd` and a
+diff of `v2.4.7...` that contains only bug fixes, the next version
+should be `v2.4.8`:
+
+```sh
+git tag -a -s -m 'Release 2.4.8' v2.4.8
+git push origin v2.4.8
+```
+
+The tag push will trigger a GitHub Actions workflow. The remaining
+steps require human intervention through the GitHub web view
+although [automated solutions
+exist](https://github.com/softprops/action-gh-release) that may be
+adopted in the future.
+
+- Open the [the new release page](https://github.com/urfave/cli/releases/new)
+- At the top of the form, click on the `Choose a tag` select control and select `v2.4.8`
+- In the `Write` tab below, click the `Auto-generate release notes` button
+- At the bottom of the form, click the `Publish release` button
+- :white_check_mark: you're done!
+
+[^1]: This was not always true. There are many **lightweight git
+  tags** present in the repository history.
+
+[^2]: This was not always true. The
+  [`docs/CHANGELOG.md`](./CHANGELOG.md) document used to be
+  manually maintained.

docs_test.go

@@ -1,133 +1,13 @@
+//go:build !urfave_cli_no_docs
+// +build !urfave_cli_no_docs
+
 package cli
 
 import (
-	"bytes"
 	"errors"
-	"io/ioutil"
 	"testing"
 )
 
-func testApp() *App {
-	app := newTestApp()
-	app.Name = "greet"
-	app.Flags = []Flag{
-		&StringFlag{
-			Name:      "socket",
-			Aliases:   []string{"s"},
-			Usage:     "some 'usage' text",
-			Value:     "value",
-			TakesFile: true,
-		},
-		&StringFlag{Name: "flag", Aliases: []string{"fl", "f"}},
-		&BoolFlag{
-			Name:    "another-flag",
-			Aliases: []string{"b"},
-			Usage:   "another usage text",
-		},
-		&BoolFlag{
-			Name:   "hidden-flag",
-			Hidden: true,
-		},
-	}
-	app.Commands = []*Command{{
-		Aliases: []string{"c"},
-		Flags: []Flag{
-			&StringFlag{
-				Name:      "flag",
-				Aliases:   []string{"fl", "f"},
-				TakesFile: true,
-			},
-			&BoolFlag{
-				Name:    "another-flag",
-				Aliases: []string{"b"},
-				Usage:   "another usage text",
-			},
-		},
-		Name:  "config",
-		Usage: "another usage test",
-		Subcommands: []*Command{{
-			Aliases: []string{"s", "ss"},
-			Flags: []Flag{
-				&StringFlag{Name: "sub-flag", Aliases: []string{"sub-fl", "s"}},
-				&BoolFlag{
-					Name:    "sub-command-flag",
-					Aliases: []string{"s"},
-					Usage:   "some usage text",
-				},
-			},
-			Name:  "sub-config",
-			Usage: "another usage test",
-		}},
-	}, {
-		Aliases: []string{"i", "in"},
-		Name:    "info",
-		Usage:   "retrieve generic information",
-	}, {
-		Name: "some-command",
-	}, {
-		Name:   "hidden-command",
-		Hidden: true,
-	}, {
-		Aliases: []string{"u"},
-		Flags: []Flag{
-			&StringFlag{
-				Name:      "flag",
-				Aliases:   []string{"fl", "f"},
-				TakesFile: true,
-			},
-			&BoolFlag{
-				Name:    "another-flag",
-				Aliases: []string{"b"},
-				Usage:   "another usage text",
-			},
-		},
-		Name:  "usage",
-		Usage: "standard usage text",
-		UsageText: `
-Usage for the usage text
-- formatted:  Based on the specified ConfigMap and summon secrets.yml
-- list:       Inspect the environment for a specific process running on a Pod
-- for_effect: Compare 'namespace' environment with 'local'
-
-` + "```" + `
-func() { ... }
-` + "```" + `
-
-Should be a part of the same code block
-`,
-		Subcommands: []*Command{{
-			Aliases: []string{"su"},
-			Flags: []Flag{
-				&BoolFlag{
-					Name:    "sub-command-flag",
-					Aliases: []string{"s"},
-					Usage:   "some usage text",
-				},
-			},
-			Name:      "sub-usage",
-			Usage:     "standard usage text",
-			UsageText: "Single line of UsageText",
-		}},
-	}}
-	app.UsageText = "app [first_arg] [second_arg]"
-	app.Description = `Description of the application.`
-	app.Usage = "Some app"
-	app.Authors = []*Author{
-		{Name: "Harrison", Email: "harrison@lolwut.com"},
-		{Name: "Oliver Allen", Email: "oliver@toyshop.com"},
-	}
-	return app
-}
-
-func expectFileContent(t *testing.T, file, got string) {
-	data, err := ioutil.ReadFile(file)
-	// Ignore windows line endings
-	// TODO: Replace with bytes.ReplaceAll when support for Go 1.11 is dropped
-	data = bytes.Replace(data, []byte("\r\n"), []byte("\n"), -1)
-	expect(t, err, nil)
-	expect(t, got, string(data))
-}
-
 func TestToMarkdownFull(t *testing.T) {
 	// Given
 	app := testApp()

fish.go

@@ -95,7 +95,7 @@ func (a *App) prepareFishCommands(commands []*Command, allCommands *[]string, pr
 		completions = append(completions, completion.String())
 		completions = append(
 			completions,
-			a.prepareFishFlags(command.Flags, command.Names())...,
+			a.prepareFishFlags(command.VisibleFlags(), command.Names())...,
 		)
 
 		// recursevly iterate subcommands

fish_test.go

@@ -1,6 +1,8 @@
 package cli
 
 import (
+	"bytes"
+	"io/ioutil"
 	"testing"
 )
 
@@ -19,3 +21,124 @@ func TestFishCompletion(t *testing.T) {
 	expect(t, err, nil)
 	expectFileContent(t, "testdata/expected-fish-full.fish", res)
 }
+
+func testApp() *App {
+	app := newTestApp()
+	app.Name = "greet"
+	app.Flags = []Flag{
+		&StringFlag{
+			Name:      "socket",
+			Aliases:   []string{"s"},
+			Usage:     "some 'usage' text",
+			Value:     "value",
+			TakesFile: true,
+		},
+		&StringFlag{Name: "flag", Aliases: []string{"fl", "f"}},
+		&BoolFlag{
+			Name:    "another-flag",
+			Aliases: []string{"b"},
+			Usage:   "another usage text",
+		},
+		&BoolFlag{
+			Name:   "hidden-flag",
+			Hidden: true,
+		},
+	}
+	app.Commands = []*Command{{
+		Aliases: []string{"c"},
+		Flags: []Flag{
+			&StringFlag{
+				Name:      "flag",
+				Aliases:   []string{"fl", "f"},
+				TakesFile: true,
+			},
+			&BoolFlag{
+				Name:    "another-flag",
+				Aliases: []string{"b"},
+				Usage:   "another usage text",
+			},
+		},
+		Name:  "config",
+		Usage: "another usage test",
+		Subcommands: []*Command{{
+			Aliases: []string{"s", "ss"},
+			Flags: []Flag{
+				&StringFlag{Name: "sub-flag", Aliases: []string{"sub-fl", "s"}},
+				&BoolFlag{
+					Name:    "sub-command-flag",
+					Aliases: []string{"s"},
+					Usage:   "some usage text",
+				},
+			},
+			Name:  "sub-config",
+			Usage: "another usage test",
+		}},
+	}, {
+		Aliases: []string{"i", "in"},
+		Name:    "info",
+		Usage:   "retrieve generic information",
+	}, {
+		Name: "some-command",
+	}, {
+		Name:   "hidden-command",
+		Hidden: true,
+	}, {
+		Aliases: []string{"u"},
+		Flags: []Flag{
+			&StringFlag{
+				Name:      "flag",
+				Aliases:   []string{"fl", "f"},
+				TakesFile: true,
+			},
+			&BoolFlag{
+				Name:    "another-flag",
+				Aliases: []string{"b"},
+				Usage:   "another usage text",
+			},
+		},
+		Name:  "usage",
+		Usage: "standard usage text",
+		UsageText: `
+Usage for the usage text
+- formatted:  Based on the specified ConfigMap and summon secrets.yml
+- list:       Inspect the environment for a specific process running on a Pod
+- for_effect: Compare 'namespace' environment with 'local'
+
+` + "```" + `
+func() { ... }
+` + "```" + `
+
+Should be a part of the same code block
+`,
+		Subcommands: []*Command{{
+			Aliases: []string{"su"},
+			Flags: []Flag{
+				&BoolFlag{
+					Name:    "sub-command-flag",
+					Aliases: []string{"s"},
+					Usage:   "some usage text",
+				},
+			},
+			Name:      "sub-usage",
+			Usage:     "standard usage text",
+			UsageText: "Single line of UsageText",
+		}},
+	}}
+	app.UsageText = "app [first_arg] [second_arg]"
+	app.Description = `Description of the application.`
+	app.Usage = "Some app"
+	app.Authors = []*Author{
+		{Name: "Harrison", Email: "harrison@lolwut.com"},
+		{Name: "Oliver Allen", Email: "oliver@toyshop.com"},
+	}
+	return app
+}
+
+func expectFileContent(t *testing.T, file, got string) {
+	data, err := ioutil.ReadFile(file)
+	// Ignore windows line endings
+	// TODO: Replace with bytes.ReplaceAll when support for Go 1.11 is dropped
+	data = bytes.Replace(data, []byte("\r\n"), []byte("\n"), -1)
+	expect(t, err, nil)
+	expect(t, got, string(data))
+}

flag-spec.yaml

@@ -0,0 +1,50 @@
+# NOTE: this file is used by the tool defined in
+# ./internal/genflags/cmd/genflags/main.go which uses the
+# `genflags.Spec` type that maps to this file structure.
+
+flag_types:
+  bool: {}
+  float64: {}
+  int64: {}
+  int: {}
+  time.Duration: {}
+  uint64: {}
+  uint: {}
+
+  string:
+    struct_fields:
+      - { name: TakesFile, type: bool }
+  Generic:
+    struct_fields:
+      - { name: TakesFile, type: bool }
+  Path:
+    struct_fields:
+      - { name: TakesFile, type: bool }
+
+  Float64Slice:
+    value_pointer: true
+    skip_interfaces:
+      - fmt.Stringer
+  Int64Slice:
+    value_pointer: true
+    skip_interfaces:
+      - fmt.Stringer
+  IntSlice:
+    value_pointer: true
+    skip_interfaces:
+      - fmt.Stringer
+  StringSlice:
+    value_pointer: true
+    skip_interfaces:
+      - fmt.Stringer
+    struct_fields:
+      - { name: TakesFile, type: bool }
+  Timestamp:
+    value_pointer: true
+    struct_fields:
+      - { name: Layout, type: string }
+
+  # TODO: enable UintSlice
+  # UintSlice: {}
+  # TODO: enable Uint64Slice once #1334 lands
+  # Uint64Slice: {}

flag.go

@@ -5,7 +5,6 @@ import (
 	"flag"
 	"fmt"
 	"io/ioutil"
-	"reflect"
 	"regexp"
 	"runtime"
 	"strconv"
@@ -244,7 +243,7 @@ func prefixedNames(names []string, placeholder string) string {
 
 func withEnvHint(envVars []string, str string) string {
 	envText := ""
-	if envVars != nil && len(envVars) > 0 {
+	if len(envVars) > 0 {
 		prefix := "$"
 		suffix := ""
 		sep := ", $"
@@ -259,7 +258,7 @@ func withEnvHint(envVars []string, str string) string {
 	return str + envText
 }
 
-func flagNames(name string, aliases []string) []string {
+func FlagNames(name string, aliases []string) []string {
 	var ret []string
 
 	for _, part := range append([]string{name}, aliases...) {
@@ -273,17 +272,6 @@ func flagNames(name string, aliases []string) []string {
 	return ret
 }
 
-func flagStringSliceField(f Flag, name string) []string {
-	fv := flagValue(f)
-	field := fv.FieldByName(name)
-
-	if field.IsValid() {
-		return field.Interface().([]string)
-	}
-
-	return []string{}
-}
-
 func withFileHint(filePath, str string) string {
 	fileText := ""
 	if filePath != "" {
@@ -292,14 +280,6 @@ func withFileHint(filePath, str string) string {
 	return str + fileText
 }
 
-func flagValue(f Flag) reflect.Value {
-	fv := reflect.ValueOf(f)
-	for fv.Kind() == reflect.Ptr {
-		fv = reflect.Indirect(fv)
-	}
-	return fv
-}
-
 func formatDefault(format string) string {
 	return " (default: " + format + ")"
 }
@@ -422,3 +402,7 @@ func flagFromEnvOrFile(envVars []string, filePath string) (val string, ok bool)
 	}
 	return "", false
 }
+
+func flagSplitMultiValues(val string) []string {
+	return strings.Split(val, ",")
+}

flag_bool.go

@@ -6,37 +6,6 @@ import (
 	"strconv"
 )
 
-// BoolFlag is a flag with type bool
-type BoolFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       bool
-	DefaultText string
-	Destination *bool
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *BoolFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *BoolFlag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *BoolFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *BoolFlag) IsRequired() bool {
 	return f.Required
@@ -102,10 +71,15 @@ func (f *BoolFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *BoolFlag) Get(ctx *Context) bool {
+	return ctx.Bool(f.Name)
+}
+
 // Bool looks up the value of a local BoolFlag, returns
 // false if not found
-func (c *Context) Bool(name string) bool {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Bool(name string) bool {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupBool(name, fs)
 	}
 	return false

flag_duration.go

@@ -6,37 +6,6 @@ import (
 	"time"
 )
 
-// DurationFlag is a flag with type time.Duration (see https://golang.org/pkg/time/#ParseDuration)
-type DurationFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       time.Duration
-	DefaultText string
-	Destination *time.Duration
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *DurationFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *DurationFlag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *DurationFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *DurationFlag) IsRequired() bool {
 	return f.Required
@@ -101,10 +70,15 @@ func (f *DurationFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *DurationFlag) Get(ctx *Context) time.Duration {
+	return ctx.Duration(f.Name)
+}
+
 // Duration looks up the value of a local DurationFlag, returns
 // 0 if not found
-func (c *Context) Duration(name string) time.Duration {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Duration(name string) time.Duration {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupDuration(name, fs)
 	}
 	return 0

flag_float64.go

@@ -6,37 +6,6 @@ import (
 	"strconv"
 )
 
-// Float64Flag is a flag with type float64
-type Float64Flag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       float64
-	DefaultText string
-	Destination *float64
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *Float64Flag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *Float64Flag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *Float64Flag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *Float64Flag) IsRequired() bool {
 	return f.Required
@@ -101,10 +70,15 @@ func (f *Float64Flag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *Float64Flag) Get(ctx *Context) float64 {
+	return ctx.Float64(f.Name)
+}
+
 // Float64 looks up the value of a local Float64Flag, returns
 // 0 if not found
-func (c *Context) Float64(name string) float64 {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Float64(name string) float64 {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupFloat64(name, fs)
 	}
 	return 0

flag_float64_slice.go

@@ -43,12 +43,14 @@ func (f *Float64Slice) Set(value string) error {
 		return nil
 	}
 
-	tmp, err := strconv.ParseFloat(value, 64)
-	if err != nil {
-		return err
-	}
+	for _, s := range flagSplitMultiValues(value) {
+		tmp, err := strconv.ParseFloat(strings.TrimSpace(s), 64)
+		if err != nil {
+			return err
+		}
 
-	f.slice = append(f.slice, tmp)
+		f.slice = append(f.slice, tmp)
+	}
 	return nil
 }
 
@@ -73,36 +75,12 @@ func (f *Float64Slice) Get() interface{} {
 	return *f
 }
 
-// Float64SliceFlag is a flag with type *Float64Slice
-type Float64SliceFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       *Float64Slice
-	DefaultText string
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *Float64SliceFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
 // String returns a readable representation of this value
 // (for usage defaults)
 func (f *Float64SliceFlag) String() string {
 	return withEnvHint(f.GetEnvVars(), stringifyFloat64SliceFlag(f))
 }
 
-// Names returns the names of the flag
-func (f *Float64SliceFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *Float64SliceFlag) IsRequired() bool {
 	return f.Required
@@ -151,7 +129,7 @@ func (f *Float64SliceFlag) Apply(set *flag.FlagSet) error {
 		if val != "" {
 			f.Value = &Float64Slice{}
 
-			for _, s := range strings.Split(val, ",") {
+			for _, s := range flagSplitMultiValues(val) {
 				if err := f.Value.Set(strings.TrimSpace(s)); err != nil {
 					return fmt.Errorf("could not parse %q as float64 slice value for flag %s: %s", f.Value, f.Name, err)
 				}
@@ -175,10 +153,15 @@ func (f *Float64SliceFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *Float64SliceFlag) Get(ctx *Context) []float64 {
+	return ctx.Float64Slice(f.Name)
+}
+
 // Float64Slice looks up the value of a local Float64SliceFlag, returns
 // nil if not found
-func (c *Context) Float64Slice(name string) []float64 {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Float64Slice(name string) []float64 {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupFloat64Slice(name, fs)
 	}
 	return nil

flag_generic.go

@@ -11,37 +11,6 @@ type Generic interface {
 	String() string
 }
 
-// GenericFlag is a flag with type Generic
-type GenericFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	TakesFile   bool
-	Value       Generic
-	DefaultText string
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *GenericFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *GenericFlag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *GenericFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *GenericFlag) IsRequired() bool {
 	return f.Required
@@ -104,10 +73,15 @@ func (f GenericFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *GenericFlag) Get(ctx *Context) interface{} {
+	return ctx.Generic(f.Name)
+}
+
 // Generic looks up the value of a local GenericFlag, returns
 // nil if not found
-func (c *Context) Generic(name string) interface{} {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Generic(name string) interface{} {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupGeneric(name, fs)
 	}
 	return nil

flag_int.go

@@ -6,37 +6,6 @@ import (
 	"strconv"
 )
 
-// IntFlag is a flag with type int
-type IntFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       int
-	DefaultText string
-	Destination *int
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *IntFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *IntFlag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *IntFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *IntFlag) IsRequired() bool {
 	return f.Required
@@ -102,10 +71,15 @@ func (f *IntFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *IntFlag) Get(ctx *Context) int {
+	return ctx.Int(f.Name)
+}
+
 // Int looks up the value of a local IntFlag, returns
 // 0 if not found
-func (c *Context) Int(name string) int {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Int(name string) int {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupInt(name, fs)
 	}
 	return 0

flag_int64.go

@@ -6,37 +6,6 @@ import (
 	"strconv"
 )
 
-// Int64Flag is a flag with type int64
-type Int64Flag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       int64
-	DefaultText string
-	Destination *int64
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *Int64Flag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *Int64Flag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *Int64Flag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *Int64Flag) IsRequired() bool {
 	return f.Required
@@ -101,10 +70,15 @@ func (f *Int64Flag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *Int64Flag) Get(ctx *Context) int64 {
+	return ctx.Int64(f.Name)
+}
+
 // Int64 looks up the value of a local Int64Flag, returns
 // 0 if not found
-func (c *Context) Int64(name string) int64 {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Int64(name string) int64 {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupInt64(name, fs)
 	}
 	return 0

flag_int64_slice.go

@@ -43,12 +43,14 @@ func (i *Int64Slice) Set(value string) error {
 		return nil
 	}
 
-	tmp, err := strconv.ParseInt(value, 0, 64)
-	if err != nil {
-		return err
-	}
+	for _, s := range flagSplitMultiValues(value) {
+		tmp, err := strconv.ParseInt(strings.TrimSpace(s), 0, 64)
+		if err != nil {
+			return err
+		}
 
-	i.slice = append(i.slice, tmp)
+		i.slice = append(i.slice, tmp)
+	}
 
 	return nil
 }
@@ -74,36 +76,12 @@ func (i *Int64Slice) Get() interface{} {
 	return *i
 }
 
-// Int64SliceFlag is a flag with type *Int64Slice
-type Int64SliceFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       *Int64Slice
-	DefaultText string
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *Int64SliceFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
 // String returns a readable representation of this value
 // (for usage defaults)
 func (f *Int64SliceFlag) String() string {
 	return withEnvHint(f.GetEnvVars(), stringifyInt64SliceFlag(f))
 }
 
-// Names returns the names of the flag
-func (f *Int64SliceFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *Int64SliceFlag) IsRequired() bool {
 	return f.Required
@@ -151,7 +129,7 @@ func (f *Int64SliceFlag) Apply(set *flag.FlagSet) error {
 	if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
 		f.Value = &Int64Slice{}
 
-		for _, s := range strings.Split(val, ",") {
+		for _, s := range flagSplitMultiValues(val) {
 			if err := f.Value.Set(strings.TrimSpace(s)); err != nil {
 				return fmt.Errorf("could not parse %q as int64 slice value for flag %s: %s", val, f.Name, err)
 			}
@@ -174,10 +152,15 @@ func (f *Int64SliceFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *Int64SliceFlag) Get(ctx *Context) []int64 {
+	return ctx.Int64Slice(f.Name)
+}
+
 // Int64Slice looks up the value of a local Int64SliceFlag, returns
 // nil if not found
-func (c *Context) Int64Slice(name string) []int64 {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Int64Slice(name string) []int64 {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupInt64Slice(name, fs)
 	}
 	return nil

flag_int_slice.go

@@ -54,12 +54,14 @@ func (i *IntSlice) Set(value string) error {
 		return nil
 	}
 
-	tmp, err := strconv.ParseInt(value, 0, 64)
-	if err != nil {
-		return err
-	}
+	for _, s := range flagSplitMultiValues(value) {
+		tmp, err := strconv.ParseInt(strings.TrimSpace(s), 0, 64)
+		if err != nil {
+			return err
+		}
 
-	i.slice = append(i.slice, int(tmp))
+		i.slice = append(i.slice, int(tmp))
+	}
 
 	return nil
 }
@@ -85,36 +87,12 @@ func (i *IntSlice) Get() interface{} {
 	return *i
 }
 
-// IntSliceFlag is a flag with type *IntSlice
-type IntSliceFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       *IntSlice
-	DefaultText string
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *IntSliceFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
 // String returns a readable representation of this value
 // (for usage defaults)
 func (f *IntSliceFlag) String() string {
 	return withEnvHint(f.GetEnvVars(), stringifyIntSliceFlag(f))
 }
 
-// Names returns the names of the flag
-func (f *IntSliceFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *IntSliceFlag) IsRequired() bool {
 	return f.Required
@@ -162,7 +140,7 @@ func (f *IntSliceFlag) Apply(set *flag.FlagSet) error {
 	if val, ok := flagFromEnvOrFile(f.EnvVars, f.FilePath); ok {
 		f.Value = &IntSlice{}
 
-		for _, s := range strings.Split(val, ",") {
+		for _, s := range flagSplitMultiValues(val) {
 			if err := f.Value.Set(strings.TrimSpace(s)); err != nil {
 				return fmt.Errorf("could not parse %q as int slice value for flag %s: %s", val, f.Name, err)
 			}
@@ -185,10 +163,15 @@ func (f *IntSliceFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *IntSliceFlag) Get(ctx *Context) []int {
+	return ctx.IntSlice(f.Name)
+}
+
 // IntSlice looks up the value of a local IntSliceFlag, returns
 // nil if not found
-func (c *Context) IntSlice(name string) []int {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) IntSlice(name string) []int {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupIntSlice(name, fs)
 	}
 	return nil

flag_path.go

@@ -5,36 +5,7 @@ import (
 	"fmt"
 )
 
-type PathFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	TakesFile   bool
-	Value       string
-	DefaultText string
-	Destination *string
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *PathFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *PathFlag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *PathFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
+type Path = string
 
 // IsRequired returns whether or not the flag is required
 func (f *PathFlag) IsRequired() bool {
@@ -96,10 +67,15 @@ func (f *PathFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *PathFlag) Get(ctx *Context) string {
+	return ctx.Path(f.Name)
+}
+
 // Path looks up the value of a local PathFlag, returns
 // "" if not found
-func (c *Context) Path(name string) string {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Path(name string) string {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupPath(name, fs)
 	}
 

flag_string.go

@@ -5,38 +5,6 @@ import (
 	"fmt"
 )
 
-// StringFlag is a flag with type string
-type StringFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	TakesFile   bool
-	Value       string
-	DefaultText string
-	Destination *string
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *StringFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *StringFlag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *StringFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *StringFlag) IsRequired() bool {
 	return f.Required
@@ -97,10 +65,15 @@ func (f *StringFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *StringFlag) Get(ctx *Context) string {
+	return ctx.String(f.Name)
+}
+
 // String looks up the value of a local StringFlag, returns
 // "" if not found
-func (c *Context) String(name string) string {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) String(name string) string {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupString(name, fs)
 	}
 	return ""

flag_string_slice.go

@@ -42,7 +42,9 @@ func (s *StringSlice) Set(value string) error {
 		return nil
 	}
 
-	s.slice = append(s.slice, value)
+	for _, t := range flagSplitMultiValues(value) {
+		s.slice = append(s.slice, strings.TrimSpace(t))
+	}
 
 	return nil
 }
@@ -68,38 +70,12 @@ func (s *StringSlice) Get() interface{} {
 	return *s
 }
 
-// StringSliceFlag is a flag with type *StringSlice
-type StringSliceFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	TakesFile   bool
-	Value       *StringSlice
-	DefaultText string
-	HasBeenSet  bool
-	Destination *StringSlice
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *StringSliceFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
 // String returns a readable representation of this value
 // (for usage defaults)
 func (f *StringSliceFlag) String() string {
 	return withEnvHint(f.GetEnvVars(), stringifyStringSliceFlag(f))
 }
 
-// Names returns the names of the flag
-func (f *StringSliceFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *StringSliceFlag) IsRequired() bool {
 	return f.Required
@@ -160,7 +136,7 @@ func (f *StringSliceFlag) Apply(set *flag.FlagSet) error {
 			destination = f.Destination
 		}
 
-		for _, s := range strings.Split(val, ",") {
+		for _, s := range flagSplitMultiValues(val) {
 			if err := destination.Set(strings.TrimSpace(s)); err != nil {
 				return fmt.Errorf("could not parse %q as string value for flag %s: %s", val, f.Name, err)
 			}
@@ -186,10 +162,15 @@ func (f *StringSliceFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *StringSliceFlag) Get(ctx *Context) []string {
+	return ctx.StringSlice(f.Name)
+}
+
 // StringSlice looks up the value of a local StringSliceFlag, returns
 // nil if not found
-func (c *Context) StringSlice(name string) []string {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) StringSlice(name string) []string {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupStringSlice(name, fs)
 	}
 	return nil

flag_test.go

@@ -51,6 +51,17 @@ func TestBoolFlagApply_SetsAllNames(t *testing.T) {
 	expect(t, v, true)
 }
 
+func TestBoolFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Bool("trueflag", true, "doc")
+	set.Bool("falseflag", false, "doc")
+	ctx := NewContext(nil, set, nil)
+	tf := &BoolFlag{Name: "trueflag"}
+	ff := &BoolFlag{Name: "falseflag"}
+	expect(t, tf.Get(ctx), true)
+	expect(t, ff.Get(ctx), false)
+}
+
 func TestFlagsFromEnv(t *testing.T) {
 	newSetFloat64Slice := func(defaults ...float64) Float64Slice {
 		s := NewFloat64Slice(defaults...)
@@ -400,7 +411,7 @@ func TestStringFlagWithEnvVarHelpOutput(t *testing.T) {
 	}
 }
 
-var prefixStringFlagTests = []struct {
+var _ = []struct {
 	name     string
 	aliases  []string
 	usage    string
@@ -439,6 +450,14 @@ func TestStringFlagApply_SetsAllNames(t *testing.T) {
 	expect(t, v, "YUUUU")
 }
 
+func TestStringFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.String("myflag", "foobar", "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &StringFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), "foobar")
+}
+
 var pathFlagTests = []struct {
 	name     string
 	aliases  []string
@@ -490,7 +509,15 @@ func TestPathFlagApply_SetsAllNames(t *testing.T) {
 	expect(t, v, "/path/to/file/PATH")
 }
 
-var envHintFlagTests = []struct {
+func TestPathFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.String("myflag", "/my/path", "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &PathFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), "/my/path")
+}
+
+var _ = []struct {
 	name     string
 	env      string
 	hinter   FlagEnvHintFunc
@@ -603,6 +630,14 @@ func TestStringSliceFlagApply_DefaultValueWithDestination(t *testing.T) {
 	expect(t, defValue, fl.Destination.Value())
 }
 
+func TestStringSliceFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Var(NewStringSlice("a", "b", "c"), "myflag", "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &StringSliceFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), []string{"a", "b", "c"})
+}
+
 var intFlagTests = []struct {
 	name     string
 	expected string
@@ -652,6 +687,14 @@ func TestIntFlagApply_SetsAllNames(t *testing.T) {
 	expect(t, v, 5)
 }
 
+func TestIntFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Int("myflag", 42, "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &IntFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), 42)
+}
+
 var int64FlagTests = []struct {
 	name     string
 	expected string
@@ -690,6 +733,14 @@ func TestInt64FlagWithEnvVarHelpOutput(t *testing.T) {
 	}
 }
 
+func TestInt64FlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Int64("myflag", 42, "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &Int64Flag{Name: "myflag"}
+	expect(t, f.Get(ctx), int64(42))
+}
+
 var uintFlagTests = []struct {
 	name     string
 	expected string
@@ -728,6 +779,14 @@ func TestUintFlagWithEnvVarHelpOutput(t *testing.T) {
 	}
 }
 
+func TestUintFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Uint("myflag", 42, "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &UintFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), uint(42))
+}
+
 var uint64FlagTests = []struct {
 	name     string
 	expected string
@@ -766,6 +825,14 @@ func TestUint64FlagWithEnvVarHelpOutput(t *testing.T) {
 	}
 }
 
+func TestUint64FlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Uint64("myflag", 42, "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &Uint64Flag{Name: "myflag"}
+	expect(t, f.Get(ctx), uint64(42))
+}
+
 var durationFlagTests = []struct {
 	name     string
 	expected string
@@ -815,6 +882,14 @@ func TestDurationFlagApply_SetsAllNames(t *testing.T) {
 	expect(t, v, time.Hour*30)
 }
 
+func TestDurationFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Duration("myflag", 42*time.Second, "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &DurationFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), 42*time.Second)
+}
+
 var intSliceFlagTests = []struct {
 	name     string
 	aliases  []string
@@ -904,6 +979,14 @@ func TestIntSliceFlag_SetFromParentContext(t *testing.T) {
 	}
 }
 
+func TestIntSliceFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Var(NewIntSlice(1, 2, 3), "myflag", "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &IntSliceFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), []int{1, 2, 3})
+}
+
 var int64SliceFlagTests = []struct {
 	name     string
 	aliases  []string
@@ -1000,6 +1083,14 @@ func TestInt64SliceFlag_ReturnNil(t *testing.T) {
 	}
 }
 
+func TestInt64SliceFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Var(NewInt64Slice(1, 2, 3), "myflag", "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &Int64SliceFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), []int64{1, 2, 3})
+}
+
 var float64FlagTests = []struct {
 	name     string
 	expected string
@@ -1049,6 +1140,14 @@ func TestFloat64FlagApply_SetsAllNames(t *testing.T) {
 	expect(t, v, float64(43.33333))
 }
 
+func TestFloat64FlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Float64("myflag", 1.23, "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &Float64Flag{Name: "myflag"}
+	expect(t, f.Get(ctx), 1.23)
+}
+
 var float64SliceFlagTests = []struct {
 	name     string
 	aliases  []string
@@ -1090,6 +1189,14 @@ func TestFloat64SliceFlagWithEnvVarHelpOutput(t *testing.T) {
 	}
 }
 
+func TestFloat64SliceFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Var(NewFloat64Slice(1.23, 4.56), "myflag", "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &Float64SliceFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), []float64{1.23, 4.56})
+}
+
 var genericFlagTests = []struct {
 	name     string
 	value    Generic
@@ -1138,6 +1245,14 @@ func TestGenericFlagApply_SetsAllNames(t *testing.T) {
 	expect(t, err, nil)
 }
 
+func TestGenericFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	set.Var(&Parser{"abc", "def"}, "myflag", "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &GenericFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), &Parser{"abc", "def"})
+}
+
 func TestParseMultiString(t *testing.T) {
 	_ = (&App{
 		Flags: []Flag{
@@ -2165,6 +2280,15 @@ func TestTimestampFlagApply_Fail_Parse_Wrong_Time(t *testing.T) {
 	expect(t, err, fmt.Errorf("invalid value \"2006-01-02T15:04:05Z\" for flag -time: parsing time \"2006-01-02T15:04:05Z\" as \"Jan 2, 2006 at 3:04pm (MST)\": cannot parse \"2006-01-02T15:04:05Z\" as \"Jan\""))
 }
 
+func TestTimestampFlagValueFromContext(t *testing.T) {
+	set := flag.NewFlagSet("test", 0)
+	now := time.Now()
+	set.Var(NewTimestamp(now), "myflag", "doc")
+	ctx := NewContext(nil, set, nil)
+	f := &TimestampFlag{Name: "myflag"}
+	expect(t, f.Get(ctx), &now)
+}
+
 type flagDefaultTestCase struct {
 	name    string
 	flag    Flag
@@ -2174,43 +2298,43 @@ type flagDefaultTestCase struct {
 
 func TestFlagDefaultValue(t *testing.T) {
 	cases := []*flagDefaultTestCase{
-		&flagDefaultTestCase{
+		{
 			name:    "stringSclice",
 			flag:    &StringSliceFlag{Name: "flag", Value: NewStringSlice("default1", "default2")},
 			toParse: []string{"--flag", "parsed"},
 			expect: `--flag value	(default: "default1", "default2")	(accepts multiple inputs)`,
 		},
-		&flagDefaultTestCase{
+		{
 			name:    "float64Sclice",
 			flag:    &Float64SliceFlag{Name: "flag", Value: NewFloat64Slice(1.1, 2.2)},
 			toParse: []string{"--flag", "13.3"},
 			expect: `--flag value	(default: 1.1, 2.2)	(accepts multiple inputs)`,
 		},
-		&flagDefaultTestCase{
+		{
 			name:    "int64Sclice",
 			flag:    &Int64SliceFlag{Name: "flag", Value: NewInt64Slice(1, 2)},
 			toParse: []string{"--flag", "13"},
 			expect: `--flag value	(default: 1, 2)	(accepts multiple inputs)`,
 		},
-		&flagDefaultTestCase{
+		{
 			name:    "intSclice",
 			flag:    &IntSliceFlag{Name: "flag", Value: NewIntSlice(1, 2)},
 			toParse: []string{"--flag", "13"},
 			expect: `--flag value	(default: 1, 2)	(accepts multiple inputs)`,
 		},
-		&flagDefaultTestCase{
+		{
 			name:    "string",
 			flag:    &StringFlag{Name: "flag", Value: "default"},
 			toParse: []string{"--flag", "parsed"},
 			expect: `--flag value	(default: "default")`,
 		},
-		&flagDefaultTestCase{
+		{
 			name:    "bool",
 			flag:    &BoolFlag{Name: "flag", Value: true},
 			toParse: []string{"--flag", "false"},
 			expect: `--flag	(default: true)`,
 		},
-		&flagDefaultTestCase{
+		{
 			name:    "uint64",
 			flag:    &Uint64Flag{Name: "flag", Value: 1},
 			toParse: []string{"--flag", "13"},
@@ -2230,6 +2354,54 @@ func TestFlagDefaultValue(t *testing.T) {
 	}
 }
 
+type flagValueTestCase struct {
+	name    string
+	flag    Flag
+	toParse []string
+	expect  string
+}
+
+func TestFlagValue(t *testing.T) {
+	cases := []*flagValueTestCase{
+		&flagValueTestCase{
+			name:    "stringSclice",
+			flag:    &StringSliceFlag{Name: "flag", Value: NewStringSlice("default1", "default2")},
+			toParse: []string{"--flag", "parsed,parsed2", "--flag", "parsed3,parsed4"},
+			expect:  `[parsed parsed2 parsed3 parsed4]`,
+		},
+		&flagValueTestCase{
+			name:    "float64Sclice",
+			flag:    &Float64SliceFlag{Name: "flag", Value: NewFloat64Slice(1.1, 2.2)},
+			toParse: []string{"--flag", "13.3,14.4", "--flag", "15.5,16.6"},
+			expect:  `[]float64{13.3, 14.4, 15.5, 16.6}`,
+		},
+		&flagValueTestCase{
+			name:    "int64Sclice",
+			flag:    &Int64SliceFlag{Name: "flag", Value: NewInt64Slice(1, 2)},
+			toParse: []string{"--flag", "13,14", "--flag", "15,16"},
+			expect:  `[]int64{13, 14, 15, 16}`,
+		},
+		&flagValueTestCase{
+			name:    "intSclice",
+			flag:    &IntSliceFlag{Name: "flag", Value: NewIntSlice(1, 2)},
+			toParse: []string{"--flag", "13,14", "--flag", "15,16"},
+			expect:  `[]int{13, 14, 15, 16}`,
+		},
+	}
+	for i, v := range cases {
+		set := flag.NewFlagSet("test", 0)
+		set.SetOutput(ioutil.Discard)
+		_ = v.flag.Apply(set)
+		if err := set.Parse(v.toParse); err != nil {
+			t.Error(err)
+		}
+		f := set.Lookup("flag")
+		if got := f.Value.String(); got != v.expect {
+			t.Errorf("TestFlagValue %d-%s\nexpect:%s\ngot:%s", i, v.name, v.expect, got)
+		}
+	}
+}
+
 func TestTimestampFlagApply_WithDestination(t *testing.T) {
 	var destination Timestamp
 	expectedResult, _ := time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")
@@ -2241,3 +2413,42 @@ func TestTimestampFlagApply_WithDestination(t *testing.T) {
 	expect(t, err, nil)
 	expect(t, *fl.Destination.timestamp, expectedResult)
 }
+
+// Test issue #1254
+// StringSlice() with UseShortOptionHandling causes duplicated entries, depending on the ordering of the flags
+func TestSliceShortOptionHandle(t *testing.T) {
+	wasCalled := false
+	err := (&App{
+		Commands: []*Command{
+			{
+				Name:                   "foobar",
+				UseShortOptionHandling: true,
+				Action: func(ctx *Context) error {
+					wasCalled = true
+					if ctx.Bool("i") != true {
+						t.Error("bool i not set")
+					}
+					if ctx.Bool("t") != true {
+						t.Error("bool i not set")
+					}
+					ss := ctx.StringSlice("net")
+					if !reflect.DeepEqual(ss, []string{"foo"}) {
+						t.Errorf("Got different slice(%v) than expected", ss)
+					}
+					return nil
+				},
+				Flags: []Flag{
+					&StringSliceFlag{Name: "net"},
+					&BoolFlag{Name: "i"},
+					&BoolFlag{Name: "t"},
+				},
+			},
+		},
+	}).Run([]string{"run", "foobar", "--net=foo", "-it"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !wasCalled {
+		t.Fatal("Action callback was never called")
+	}
+}

flag_timestamp.go

@@ -58,38 +58,6 @@ func (t *Timestamp) Get() interface{} {
 	return *t
 }
 
-// TimestampFlag is a flag with type time
-type TimestampFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Layout      string
-	Value       *Timestamp
-	DefaultText string
-	HasBeenSet  bool
-	Destination *Timestamp
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *TimestampFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *TimestampFlag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *TimestampFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *TimestampFlag) IsRequired() bool {
 	return f.Required
@@ -164,9 +132,14 @@ func (f *TimestampFlag) Apply(set *flag.FlagSet) error {
 	return nil
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *TimestampFlag) Get(ctx *Context) *time.Time {
+	return ctx.Timestamp(f.Name)
+}
+
 // Timestamp gets the timestamp from a flag name
-func (c *Context) Timestamp(name string) *time.Time {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Timestamp(name string) *time.Time {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupTimestamp(name, fs)
 	}
 	return nil

flag_uint.go

@@ -6,37 +6,6 @@ import (
 	"strconv"
 )
 
-// UintFlag is a flag with type uint
-type UintFlag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       uint
-	DefaultText string
-	Destination *uint
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *UintFlag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *UintFlag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *UintFlag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *UintFlag) IsRequired() bool {
 	return f.Required
@@ -101,10 +70,15 @@ func (f *UintFlag) GetEnvVars() []string {
 	return f.EnvVars
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *UintFlag) Get(ctx *Context) uint {
+	return ctx.Uint(f.Name)
+}
+
 // Uint looks up the value of a local UintFlag, returns
 // 0 if not found
-func (c *Context) Uint(name string) uint {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Uint(name string) uint {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupUint(name, fs)
 	}
 	return 0

flag_uint64.go

@@ -6,37 +6,6 @@ import (
 	"strconv"
 )
 
-// Uint64Flag is a flag with type uint64
-type Uint64Flag struct {
-	Name        string
-	Aliases     []string
-	Usage       string
-	EnvVars     []string
-	FilePath    string
-	Required    bool
-	Hidden      bool
-	Value       uint64
-	DefaultText string
-	Destination *uint64
-	HasBeenSet  bool
-}
-
-// IsSet returns whether or not the flag has been set through env or file
-func (f *Uint64Flag) IsSet() bool {
-	return f.HasBeenSet
-}
-
-// String returns a readable representation of this value
-// (for usage defaults)
-func (f *Uint64Flag) String() string {
-	return FlagStringer(f)
-}
-
-// Names returns the names of the flag
-func (f *Uint64Flag) Names() []string {
-	return flagNames(f.Name, f.Aliases)
-}
-
 // IsRequired returns whether or not the flag is required
 func (f *Uint64Flag) IsRequired() bool {
 	return f.Required
@@ -101,10 +70,15 @@ func (f *Uint64Flag) GetEnvVars() []string {
 	return f.EnvVars
 }
 
+// Get returns the flag’s value in the given Context.
+func (f *Uint64Flag) Get(ctx *Context) uint64 {
+	return ctx.Uint64(f.Name)
+}
+
 // Uint64 looks up the value of a local Uint64Flag, returns
 // 0 if not found
-func (c *Context) Uint64(name string) uint64 {
-	if fs := c.lookupFlagSet(name); fs != nil {
+func (cCtx *Context) Uint64(name string) uint64 {
+	if fs := cCtx.lookupFlagSet(name); fs != nil {
 		return lookupUint64(name, fs)
 	}
 	return 0

funcs.go

@@ -21,11 +21,11 @@ type CommandNotFoundFunc func(*Context, string)
 // customized usage error messages.  This function is able to replace the
 // original error messages.  If this function is not set, the "Incorrect usage"
 // is displayed and the execution is interrupted.
-type OnUsageErrorFunc func(context *Context, err error, isSubcommand bool) error
+type OnUsageErrorFunc func(cCtx *Context, err error, isSubcommand bool) error
 
 // ExitErrHandlerFunc is executed if provided in order to handle exitError values
 // returned by Actions and Before/After functions.
-type ExitErrHandlerFunc func(context *Context, err error)
+type ExitErrHandlerFunc func(cCtx *Context, err error)
 
 // FlagStringFunc is used by the help generation to display a flag, which is
 // expected to be a single line.

go.mod

@@ -5,6 +5,7 @@ go 1.18
 require (
 	github.com/BurntSushi/toml v1.1.0
 	github.com/cpuguy83/go-md2man/v2 v2.0.1
+	golang.org/x/text v0.3.7
 	gopkg.in/yaml.v2 v2.4.0
 )
 

go.sum

@@ -1,11 +1,13 @@
-github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
 github.com/BurntSushi/toml v1.1.0 h1:ksErzDEI1khOiGPgpwuI7x2ebx/uXQNw7xJpn9Eq1+I=
 github.com/BurntSushi/toml v1.1.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/cpuguy83/go-md2man/v2 v2.0.1 h1:r/myEWzV9lfsM1tFLgDyu0atFtJ1fXn261LKYj/3DxU=
 github.com/cpuguy83/go-md2man/v2 v2.0.1/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
 github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
+golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e h1:FDhOuMEY4JVRztM/gsbk+IKUQ8kj74bxZrgw87eMMVc=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=

help.go

@@ -15,13 +15,13 @@ var helpCommand = &Command{
 	Aliases:   []string{"h"},
 	Usage:     "Shows a list of commands or help for one command",
 	ArgsUsage: "[command]",
-	Action: func(c *Context) error {
-		args := c.Args()
+	Action: func(cCtx *Context) error {
+		args := cCtx.Args()
 		if args.Present() {
-			return ShowCommandHelp(c, args.First())
+			return ShowCommandHelp(cCtx, args.First())
 		}
 
-		_ = ShowAppHelp(c)
+		_ = ShowAppHelp(cCtx)
 		return nil
 	},
 }
@@ -31,13 +31,13 @@ var helpSubcommand = &Command{
 	Aliases:   []string{"h"},
 	Usage:     "Shows a list of commands or help for one command",
 	ArgsUsage: "[command]",
-	Action: func(c *Context) error {
-		args := c.Args()
+	Action: func(cCtx *Context) error {
+		args := cCtx.Args()
 		if args.Present() {
-			return ShowCommandHelp(c, args.First())
+			return ShowCommandHelp(cCtx, args.First())
 		}
 
-		return ShowSubcommandHelp(c)
+		return ShowSubcommandHelp(cCtx)
 	},
 }
 
@@ -71,30 +71,30 @@ func ShowAppHelpAndExit(c *Context, exitCode int) {
 }
 
 // ShowAppHelp is an action that displays the help.
-func ShowAppHelp(c *Context) error {
-	tpl := c.App.CustomAppHelpTemplate
+func ShowAppHelp(cCtx *Context) error {
+	tpl := cCtx.App.CustomAppHelpTemplate
 	if tpl == "" {
 		tpl = AppHelpTemplate
 	}
 
-	if c.App.ExtraInfo == nil {
-		HelpPrinter(c.App.Writer, tpl, c.App)
+	if cCtx.App.ExtraInfo == nil {
+		HelpPrinter(cCtx.App.Writer, tpl, cCtx.App)
 		return nil
 	}
 
 	customAppData := func() map[string]interface{} {
 		return map[string]interface{}{
-			"ExtraInfo": c.App.ExtraInfo,
+			"ExtraInfo": cCtx.App.ExtraInfo,
 		}
 	}
-	HelpPrinterCustom(c.App.Writer, tpl, c.App, customAppData())
+	HelpPrinterCustom(cCtx.App.Writer, tpl, cCtx.App, customAppData())
 
 	return nil
 }
 
 // DefaultAppComplete prints the list of subcommands as the default app completion method
-func DefaultAppComplete(c *Context) {
-	DefaultCompleteWithFlags(nil)(c)
+func DefaultAppComplete(cCtx *Context) {
+	DefaultCompleteWithFlags(nil)(cCtx)
 }
 
 func printCommandSuggestions(commands []*Command, writer io.Writer) {
@@ -159,30 +159,30 @@ func printFlagSuggestions(lastArg string, flags []Flag, writer io.Writer) {
 	}
 }
 
-func DefaultCompleteWithFlags(cmd *Command) func(c *Context) {
-	return func(c *Context) {
+func DefaultCompleteWithFlags(cmd *Command) func(cCtx *Context) {
+	return func(cCtx *Context) {
 		if len(os.Args) > 2 {
 			lastArg := os.Args[len(os.Args)-2]
 
 			if strings.HasPrefix(lastArg, "-") {
 				if cmd != nil {
-					printFlagSuggestions(lastArg, cmd.Flags, c.App.Writer)
+					printFlagSuggestions(lastArg, cmd.Flags, cCtx.App.Writer)
 
 					return
 				}
 
-				printFlagSuggestions(lastArg, c.App.Flags, c.App.Writer)
+				printFlagSuggestions(lastArg, cCtx.App.Flags, cCtx.App.Writer)
 
 				return
 			}
 		}
 
 		if cmd != nil {
-			printCommandSuggestions(cmd.Subcommands, c.App.Writer)
+			printCommandSuggestions(cmd.Subcommands, cCtx.App.Writer)
 			return
 		}
 
-		printCommandSuggestions(c.App.Commands, c.App.Writer)
+		printCommandSuggestions(cCtx.App.Commands, cCtx.App.Writer)
 	}
 }
 
@@ -228,32 +228,32 @@ func ShowSubcommandHelpAndExit(c *Context, exitCode int) {
 }
 
 // ShowSubcommandHelp prints help for the given subcommand
-func ShowSubcommandHelp(c *Context) error {
-	if c == nil {
+func ShowSubcommandHelp(cCtx *Context) error {
+	if cCtx == nil {
 		return nil
 	}
 
-	if c.Command != nil {
-		return ShowCommandHelp(c, c.Command.Name)
+	if cCtx.Command != nil {
+		return ShowCommandHelp(cCtx, cCtx.Command.Name)
 	}
 
-	return ShowCommandHelp(c, "")
+	return ShowCommandHelp(cCtx, "")
 }
 
 // ShowVersion prints the version number of the App
-func ShowVersion(c *Context) {
-	VersionPrinter(c)
+func ShowVersion(cCtx *Context) {
+	VersionPrinter(cCtx)
 }
 
-func printVersion(c *Context) {
-	_, _ = fmt.Fprintf(c.App.Writer, "%v version %v\n", c.App.Name, c.App.Version)
+func printVersion(cCtx *Context) {
+	_, _ = fmt.Fprintf(cCtx.App.Writer, "%v version %v\n", cCtx.App.Name, cCtx.App.Version)
 }
 
 // ShowCompletions prints the lists of commands within a given context
-func ShowCompletions(c *Context) {
-	a := c.App
+func ShowCompletions(cCtx *Context) {
+	a := cCtx.App
 	if a != nil && a.BashComplete != nil {
-		a.BashComplete(c)
+		a.BashComplete(cCtx)
 	}
 }
 
@@ -304,20 +304,20 @@ func printHelp(out io.Writer, templ string, data interface{}) {
 	HelpPrinterCustom(out, templ, data, nil)
 }
 
-func checkVersion(c *Context) bool {
+func checkVersion(cCtx *Context) bool {
 	found := false
 	for _, name := range VersionFlag.Names() {
-		if c.Bool(name) {
+		if cCtx.Bool(name) {
 			found = true
 		}
 	}
 	return found
 }
 
-func checkHelp(c *Context) bool {
+func checkHelp(cCtx *Context) bool {
 	found := false
 	for _, name := range HelpFlag.Names() {
-		if c.Bool(name) {
+		if cCtx.Bool(name) {
 			found = true
 		}
 	}
@@ -333,9 +333,9 @@ func checkCommandHelp(c *Context, name string) bool {
 	return false
 }
 
-func checkSubcommandHelp(c *Context) bool {
-	if c.Bool("h") || c.Bool("help") {
-		_ = ShowSubcommandHelp(c)
+func checkSubcommandHelp(cCtx *Context) bool {
+	if cCtx.Bool("h") || cCtx.Bool("help") {
+		_ = ShowSubcommandHelp(cCtx)
 		return true
 	}
 
@@ -357,20 +357,20 @@ func checkShellCompleteFlag(a *App, arguments []string) (bool, []string) {
 	return true, arguments[:pos]
 }
 
-func checkCompletions(c *Context) bool {
-	if !c.shellComplete {
+func checkCompletions(cCtx *Context) bool {
+	if !cCtx.shellComplete {
 		return false
 	}
 
-	if args := c.Args(); args.Present() {
+	if args := cCtx.Args(); args.Present() {
 		name := args.First()
-		if cmd := c.App.Command(name); cmd != nil {
+		if cmd := cCtx.App.Command(name); cmd != nil {
 			// let the command handle the completion
 			return false
 		}
 	}
 
-	ShowCompletions(c)
+	ShowCompletions(cCtx)
 	return true
 }
 

internal/build/build.go

@@ -6,19 +6,45 @@ import (
 	"bufio"
 	"bytes"
 	"fmt"
-	"io/ioutil"
 	"log"
 	"math"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 
 	"github.com/urfave/cli/v2"
 )
 
-var packages = []string{"cli", "altsrc"}
+const (
+	badNewsEmoji      = "🚨"
+	goodNewsEmoji     = "✨"
+	checksPassedEmoji = "✅"
+
+	v2diffWarning = `
+# The unified diff above indicates that the public API surface area
+# has changed. If you feel that the changes are acceptable and adhere
+# to the semantic versioning promise of the v2.x series described in
+# docs/CONTRIBUTING.md, please run the following command to promote
+# the current go docs:
+#
+#     make v2approve
+#
+`
+)
 
 func main() {
+	top, err := func() (string, error) {
+		if v, err := sh("git", "rev-parse", "--show-toplevel"); err == nil {
+			return strings.TrimSpace(v), nil
+		}
+
+		return os.Getwd()
+	}()
+	if err != nil {
+		log.Fatal(err)
+	}
+
 	app := cli.NewApp()
 
 	app.Name = "builder"
@@ -45,14 +71,52 @@ func main() {
 			Name:   "check-binary-size",
 			Action: checkBinarySizeActionFunc,
 		},
+		{
+			Name:   "generate",
+			Action: GenerateActionFunc,
+		},
+		{
+			Name: "v2diff",
+			Flags: []cli.Flag{
+				&cli.BoolFlag{Name: "color", Value: false},
+			},
+			Action: V2Diff,
+		},
+		{
+			Name:   "v2approve",
+			Action: V2Approve,
+		},
+	}
+	app.Flags = []cli.Flag{
+		&cli.StringFlag{
+			Name:  "tags",
+			Usage: "set build tags",
+		},
+		&cli.PathFlag{
+			Name:  "top",
+			Value: top,
+		},
+		&cli.StringSliceFlag{
+			Name:  "packages",
+			Value: cli.NewStringSlice("cli", "altsrc", "internal/build", "internal/genflags"),
+		},
 	}
 
-	err := app.Run(os.Args)
-	if err != nil {
+	if err := app.Run(os.Args); err != nil {
 		log.Fatal(err)
 	}
 }
 
+func sh(exe string, args ...string) (string, error) {
+	cmd := exec.Command(exe, args...)
+	cmd.Stdin = os.Stdin
+	cmd.Stderr = os.Stderr
+
+	fmt.Fprintf(os.Stderr, "# ---> %s\n", cmd)
+	outBytes, err := cmd.Output()
+	return string(outBytes), err
+}
+
 func runCmd(arg string, args ...string) error {
 	cmd := exec.Command(arg, args...)
 
@@ -60,76 +124,63 @@ func runCmd(arg string, args ...string) error {
 	cmd.Stdout = os.Stdout
 	cmd.Stderr = os.Stderr
 
+	fmt.Fprintf(os.Stderr, "# ---> %s\n", cmd)
 	return cmd.Run()
 }
 
-func VetActionFunc(_ *cli.Context) error {
-	return runCmd("go", "vet")
+func VetActionFunc(cCtx *cli.Context) error {
+	return runCmd("go", "vet", cCtx.Path("top")+"/...")
 }
 
 func TestActionFunc(c *cli.Context) error {
-	for _, pkg := range packages {
-		var packageName string
+	tags := c.String("tags")
+
+	for _, pkg := range c.StringSlice("packages") {
+		packageName := "github.com/urfave/cli/v2"
 
-		if pkg == "cli" {
-			packageName = "github.com/urfave/cli/v2"
-		} else {
+		if pkg != "cli" {
 			packageName = fmt.Sprintf("github.com/urfave/cli/v2/%s", pkg)
 		}
 
-		coverProfile := fmt.Sprintf("--coverprofile=%s.coverprofile", pkg)
-
-		err := runCmd("go", "test", "-v", coverProfile, packageName)
-		if err != nil {
+		if err := runCmd(
+			"go", "test",
+			"-tags", tags,
+			"-v",
+			"--coverprofile", pkg+".coverprofile",
+			"--covermode", "count",
+			"--cover", packageName,
+			packageName,
+		); err != nil {
 			return err
 		}
 	}
 
-	return testCleanup()
+	return testCleanup(c.StringSlice("packages"))
 }
 
-func testCleanup() error {
-	var out bytes.Buffer
+func testCleanup(packages []string) error {
+	out := &bytes.Buffer{}
+
+	fmt.Fprintf(out, "mode: count\n")
 
 	for _, pkg := range packages {
-		file, err := os.Open(fmt.Sprintf("%s.coverprofile", pkg))
-		if err != nil {
-			return err
-		}
+		filename := pkg + ".coverprofile"
 
-		b, err := ioutil.ReadAll(file)
+		lineBytes, err := os.ReadFile(filename)
 		if err != nil {
 			return err
 		}
 
-		out.Write(b)
-		err = file.Close()
-		if err != nil {
-			return err
-		}
+		lines := strings.Split(string(lineBytes), "\n")
 
-		err = os.Remove(fmt.Sprintf("%s.coverprofile", pkg))
-		if err != nil {
+		fmt.Fprintf(out, strings.Join(lines[1:], "\n"))
+
+		if err := os.Remove(filename); err != nil {
 			return err
 		}
 	}
 
-	outFile, err := os.Create("coverage.txt")
-	if err != nil {
-		return err
-	}
-
-	_, err = out.WriteTo(outFile)
-	if err != nil {
-		return err
-	}
-
-	err = outFile.Close()
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return os.WriteFile("coverage.txt", out.Bytes(), 0644)
 }
 
 func GfmrunActionFunc(c *cli.Context) error {
@@ -171,17 +222,7 @@ func TocActionFunc(c *cli.Context) error {
 		filename = "README.md"
 	}
 
-	err := runCmd("markdown-toc", "-i", filename)
-	if err != nil {
-		return err
-	}
-
-	err = runCmd("git", "diff", "--exit-code")
-	if err != nil {
-		return err
-	}
-
-	return nil
+	return runCmd("markdown-toc", "-i", filename)
 }
 
 // checkBinarySizeActionFunc checks the size of an example binary to ensure that we are keeping size down
@@ -193,22 +234,26 @@ func checkBinarySizeActionFunc(c *cli.Context) (err error) {
 		cliBuiltFilePath     = "./internal/example-cli/built-example"
 		helloSourceFilePath  = "./internal/example-hello-world/example-hello-world.go"
 		helloBuiltFilePath   = "./internal/example-hello-world/built-example"
-		desiredMinBinarySize = 1.675
 		desiredMaxBinarySize = 2.2
-		badNewsEmoji         = "🚨"
-		goodNewsEmoji        = "✨"
-		checksPassedEmoji    = "✅"
 		mbStringFormatter    = "%.1fMB"
 	)
 
+	desiredMinBinarySize := 1.675
+
+	tags := c.String("tags")
+
+	if strings.Contains(tags, "urfave_cli_no_docs") {
+		desiredMinBinarySize = 1.39
+	}
+
 	// get cli example size
-	cliSize, err := getSize(cliSourceFilePath, cliBuiltFilePath)
+	cliSize, err := getSize(cliSourceFilePath, cliBuiltFilePath, tags)
 	if err != nil {
 		return err
 	}
 
 	// get hello world size
-	helloSize, err := getSize(helloSourceFilePath, helloBuiltFilePath)
+	helloSize, err := getSize(helloSourceFilePath, helloBuiltFilePath, tags)
 	if err != nil {
 		return err
 	}
@@ -270,9 +315,72 @@ func checkBinarySizeActionFunc(c *cli.Context) (err error) {
 	return nil
 }
 
-func getSize(sourcePath string, builtPath string) (size int64, err error) {
+func GenerateActionFunc(cCtx *cli.Context) error {
+	top := cCtx.Path("top")
+
+	cliDocs, err := sh("go", "doc", "-all", top)
+	if err != nil {
+		return err
+	}
+
+	altsrcDocs, err := sh("go", "doc", "-all", filepath.Join(top, "altsrc"))
+	if err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(
+		filepath.Join(top, "godoc-current.txt"),
+		[]byte(cliDocs+altsrcDocs),
+		0644,
+	); err != nil {
+		return err
+	}
+
+	return runCmd("go", "generate", cCtx.Path("top")+"/...")
+}
+
+func V2Diff(cCtx *cli.Context) error {
+	os.Chdir(cCtx.Path("top"))
+
+	err := runCmd(
+		"diff",
+		"--ignore-all-space",
+		"--minimal",
+		"--color="+func() string {
+			if cCtx.Bool("color") {
+				return "always"
+			}
+			return "auto"
+		}(),
+		"--unified",
+		"--label=a/godoc",
+		filepath.Join("testdata", "godoc-v2.x.txt"),
+		"--label=b/godoc",
+		"godoc-current.txt",
+	)
+
+	if err != nil {
+		fmt.Printf("# %v ---> Hey! <---\n", badNewsEmoji)
+		fmt.Println(strings.TrimSpace(v2diffWarning))
+	}
+
+	return err
+}
+
+func V2Approve(cCtx *cli.Context) error {
+	top := cCtx.Path("top")
+
+	return runCmd(
+		"cp",
+		"-v",
+		filepath.Join(top, "godoc-current.txt"),
+		filepath.Join(top, "testdata", "godoc-v2.x.txt"),
+	)
+}
+
+func getSize(sourcePath string, builtPath string, tags string) (size int64, err error) {
 	// build example binary
-	err = runCmd("go", "build", "-o", builtPath, "-ldflags", "-s -w", sourcePath)
+	err = runCmd("go", "build", "-tags", tags, "-o", builtPath, "-ldflags", "-s -w", sourcePath)
 	if err != nil {
 		fmt.Println("issue getting size for example binary")
 		return 0, err

internal/genflags/cmd/genflags/main.go

@@ -0,0 +1,163 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	_ "embed"
+	"log"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"text/template"
+
+	"github.com/urfave/cli/v2"
+	"github.com/urfave/cli/v2/internal/genflags"
+	"gopkg.in/yaml.v2"
+)
+
+const (
+	defaultPackageName = "cli"
+)
+
+func sh(ctx context.Context, exe string, args ...string) (string, error) {
+	cmd := exec.CommandContext(ctx, exe, args...)
+	cmd.Stderr = os.Stderr
+	outBytes, err := cmd.Output()
+	return string(outBytes), err
+}
+
+func main() {
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+
+	top := "../../"
+	if v, err := sh(ctx, "git", "rev-parse", "--show-toplevel"); err == nil {
+		top = strings.TrimSpace(v)
+	}
+
+	app := &cli.App{
+		Name:  "genflags",
+		Usage: "Generate flag types for urfave/cli",
+		Flags: []cli.Flag{
+			&cli.PathFlag{
+				Name:    "flag-spec-yaml",
+				Aliases: []string{"f"},
+				Value:   filepath.Join(top, "flag-spec.yaml"),
+			},
+			&cli.PathFlag{
+				Name:    "generated-output",
+				Aliases: []string{"o"},
+				Value:   filepath.Join(top, "zz_generated.flags.go"),
+			},
+			&cli.PathFlag{
+				Name:    "generated-test-output",
+				Aliases: []string{"t"},
+				Value:   filepath.Join(top, "zz_generated.flags_test.go"),
+			},
+			&cli.StringFlag{
+				Name:    "generated-package-name",
+				Aliases: []string{"p"},
+				Value:   defaultPackageName,
+			},
+			&cli.StringFlag{
+				Name:    "generated-test-package-name",
+				Aliases: []string{"T"},
+				Value:   defaultPackageName + "_test",
+			},
+			&cli.StringFlag{
+				Name:    "urfave-cli-namespace",
+				Aliases: []string{"n"},
+				Value:   "",
+			},
+			&cli.StringFlag{
+				Name:    "urfave-cli-test-namespace",
+				Aliases: []string{"N"},
+				Value:   "cli.",
+			},
+		},
+		Action: runGenFlags,
+	}
+
+	if err := app.RunContext(ctx, os.Args); err != nil {
+		log.Fatal(err)
+	}
+}
+
+func runGenFlags(cCtx *cli.Context) error {
+	specBytes, err := os.ReadFile(cCtx.Path("flag-spec-yaml"))
+	if err != nil {
+		return err
+	}
+
+	spec := &genflags.Spec{}
+	if err := yaml.Unmarshal(specBytes, spec); err != nil {
+		return err
+	}
+
+	if cCtx.IsSet("generated-package-name") {
+		spec.PackageName = strings.TrimSpace(cCtx.String("generated-package-name"))
+	}
+
+	if strings.TrimSpace(spec.PackageName) == "" {
+		spec.PackageName = defaultPackageName
+	}
+
+	if cCtx.IsSet("generated-test-package-name") {
+		spec.TestPackageName = strings.TrimSpace(cCtx.String("generated-test-package-name"))
+	}
+
+	if strings.TrimSpace(spec.TestPackageName) == "" {
+		spec.TestPackageName = defaultPackageName + "_test"
+	}
+
+	if cCtx.IsSet("urfave-cli-namespace") {
+		spec.UrfaveCLINamespace = strings.TrimSpace(cCtx.String("urfave-cli-namespace"))
+	}
+
+	if cCtx.IsSet("urfave-cli-test-namespace") {
+		spec.UrfaveCLITestNamespace = strings.TrimSpace(cCtx.String("urfave-cli-test-namespace"))
+	} else {
+		spec.UrfaveCLITestNamespace = "cli."
+	}
+
+	genTmpl, err := template.New("gen").Parse(genflags.TemplateString)
+	if err != nil {
+		return err
+	}
+
+	genTestTmpl, err := template.New("gen_test").Parse(genflags.TestTemplateString)
+	if err != nil {
+		return err
+	}
+
+	genBuf := &bytes.Buffer{}
+	if err := genTmpl.Execute(genBuf, spec); err != nil {
+		return err
+	}
+
+	genTestBuf := &bytes.Buffer{}
+	if err := genTestTmpl.Execute(genTestBuf, spec); err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(cCtx.Path("generated-output"), genBuf.Bytes(), 0644); err != nil {
+		return err
+	}
+
+	if err := os.WriteFile(cCtx.Path("generated-test-output"), genTestBuf.Bytes(), 0644); err != nil {
+		return err
+	}
+
+	if _, err := sh(cCtx.Context, "goimports", "-w", cCtx.Path("generated-output")); err != nil {
+		return err
+	}
+
+	if _, err := sh(cCtx.Context, "goimports", "-w", cCtx.Path("generated-test-output")); err != nil {
+		return err
+	}
+
+	return nil
+}

internal/genflags/generated.gotmpl

@@ -0,0 +1,53 @@
+// WARNING: this file is generated. DO NOT EDIT
+
+package {{.PackageName}}
+
+{{range .SortedFlagTypes}}
+// {{.TypeName}} is a flag with type {{if .ValuePointer}}*{{end}}{{.GoType}}
+type {{.TypeName}} struct {
+  Name string
+
+  DefaultText string
+  FilePath string
+  Usage string
+
+  Required bool
+  Hidden bool
+  HasBeenSet bool
+
+  Value {{if .ValuePointer}}*{{end}}{{.GoType}}
+  Destination *{{.GoType}}
+
+  Aliases []string
+  EnvVars []string
+
+  {{range .StructFields}}
+  {{.Name}} {{.Type}}
+  {{end}}
+}
+
+{{if .GenerateFmtStringerInterface}}
+// String returns a readable representation of this value (for usage defaults)
+func (f *{{.TypeName}}) String() string {
+  return {{$.UrfaveCLINamespace}}FlagStringer(f)
+}
+{{end}}
+
+{{if .GenerateFlagInterface}}
+// IsSet returns whether or not the flag has been set through env or file
+func (f *{{.TypeName}}) IsSet() bool {
+  return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *{{.TypeName}}) Names() []string {
+  return {{$.UrfaveCLINamespace}}FlagNames(f.Name, f.Aliases)
+}
+
+{{end}}{{/* /if .GenerateFlagInterface */}}
+{{end}}{{/* /range .SortedFlagTypes */}}
+
+// vim{{/* 👻 */}}:ro
+{{/*
+vim:filetype=gotexttmpl
+*/}}

internal/genflags/generated_test.gotmpl

@@ -0,0 +1,27 @@
+// WARNING: this file is generated. DO NOT EDIT
+
+package {{.TestPackageName}}
+
+{{range .SortedFlagTypes}}
+{{if .GenerateFlagInterface}}
+func Test{{.TypeName}}_SatisfiesFlagInterface(t *testing.T) {
+  var f {{$.UrfaveCLITestNamespace}}Flag = &{{$.UrfaveCLITestNamespace}}{{.TypeName}}{}
+
+  _ = f.IsSet()
+  _ = f.Names()
+}
+{{end}}
+
+{{if .GenerateFmtStringerInterface}}
+func Test{{.TypeName}}_SatisfiesFmtStringerInterface(t *testing.T) {
+  var f fmt.Stringer = &{{$.UrfaveCLITestNamespace}}{{.TypeName}}{}
+
+  _ = f.String()
+}
+{{end}}
+{{end}}
+
+// vim{{/* 👻 */}}:ro
+{{/*
+vim:filetype=gotexttmpl
+*/}}

internal/genflags/package.go

@@ -0,0 +1,34 @@
+package genflags
+
+import (
+	_ "embed"
+	"strings"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+)
+
+var (
+	//go:embed generated.gotmpl
+	TemplateString string
+
+	//go:embed generated_test.gotmpl
+	TestTemplateString string
+
+	titler = cases.Title(language.Und, cases.NoLower)
+)
+
+func TypeName(goType string, fc *FlagTypeConfig) string {
+	if fc != nil && strings.TrimSpace(fc.TypeName) != "" {
+		return strings.TrimSpace(fc.TypeName)
+	}
+
+	dotSplit := strings.Split(goType, ".")
+	goType = dotSplit[len(dotSplit)-1]
+
+	if strings.HasPrefix(goType, "[]") {
+		return titler.String(strings.TrimPrefix(goType, "[]")) + "SliceFlag"
+	}
+
+	return titler.String(goType) + "Flag"
+}

internal/genflags/package_test.go

@@ -0,0 +1,41 @@
+package genflags_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/urfave/cli/v2/internal/genflags"
+)
+
+func TestTypeName(t *testing.T) {
+	for _, tc := range []struct {
+		gt       string
+		fc       *genflags.FlagTypeConfig
+		expected string
+	}{
+		{gt: "int", fc: nil, expected: "IntFlag"},
+		{gt: "int", fc: &genflags.FlagTypeConfig{}, expected: "IntFlag"},
+		{gt: "int", fc: &genflags.FlagTypeConfig{TypeName: "VeryIntyFlag"}, expected: "VeryIntyFlag"},
+		{gt: "[]bool", fc: nil, expected: "BoolSliceFlag"},
+		{gt: "[]bool", fc: &genflags.FlagTypeConfig{}, expected: "BoolSliceFlag"},
+		{gt: "[]bool", fc: &genflags.FlagTypeConfig{TypeName: "ManyTruthsFlag"}, expected: "ManyTruthsFlag"},
+		{gt: "time.Rumination", fc: nil, expected: "RuminationFlag"},
+		{gt: "time.Rumination", fc: &genflags.FlagTypeConfig{}, expected: "RuminationFlag"},
+		{gt: "time.Rumination", fc: &genflags.FlagTypeConfig{TypeName: "PonderFlag"}, expected: "PonderFlag"},
+	} {
+		t.Run(
+			fmt.Sprintf("type=%s,cfg=%v", tc.gt, func() string {
+				if tc.fc != nil {
+					return tc.fc.TypeName
+				}
+				return "nil"
+			}()),
+			func(ct *testing.T) {
+				actual := genflags.TypeName(tc.gt, tc.fc)
+				if tc.expected != actual {
+					ct.Errorf("expected %q, got %q", tc.expected, actual)
+				}
+			},
+		)
+	}
+}

internal/genflags/spec.go

@@ -0,0 +1,100 @@
+package genflags
+
+import (
+	"sort"
+	"strings"
+)
+
+type Spec struct {
+	FlagTypes              map[string]*FlagTypeConfig `yaml:"flag_types"`
+	PackageName            string                     `yaml:"package_name"`
+	TestPackageName        string                     `yaml:"test_package_name"`
+	UrfaveCLINamespace     string                     `yaml:"urfave_cli_namespace"`
+	UrfaveCLITestNamespace string                     `yaml:"urfave_cli_test_namespace"`
+}
+
+func (gfs *Spec) SortedFlagTypes() []*FlagType {
+	typeNames := []string{}
+
+	for name := range gfs.FlagTypes {
+		if strings.HasPrefix(name, "[]") {
+			name = strings.TrimPrefix(name, "[]") + "Slice"
+		}
+
+		typeNames = append(typeNames, name)
+	}
+
+	sort.Strings(typeNames)
+
+	ret := make([]*FlagType, len(typeNames))
+
+	for i, typeName := range typeNames {
+		ret[i] = &FlagType{
+			GoType: typeName,
+			Config: gfs.FlagTypes[typeName],
+		}
+	}
+
+	return ret
+}
+
+type FlagTypeConfig struct {
+	SkipInterfaces []string           `yaml:"skip_interfaces"`
+	StructFields   []*FlagStructField `yaml:"struct_fields"`
+	TypeName       string             `yaml:"type_name"`
+	ValuePointer   bool               `yaml:"value_pointer"`
+}
+
+type FlagStructField struct {
+	Name string
+	Type string
+}
+
+type FlagType struct {
+	GoType string
+	Config *FlagTypeConfig
+}
+
+func (ft *FlagType) StructFields() []*FlagStructField {
+	if ft.Config == nil || ft.Config.StructFields == nil {
+		return []*FlagStructField{}
+	}
+
+	return ft.Config.StructFields
+}
+
+func (ft *FlagType) ValuePointer() bool {
+	if ft.Config == nil {
+		return false
+	}
+
+	return ft.Config.ValuePointer
+}
+
+func (ft *FlagType) TypeName() string {
+	return TypeName(ft.GoType, ft.Config)
+}
+
+func (ft *FlagType) GenerateFmtStringerInterface() bool {
+	return ft.skipInterfaceNamed("fmt.Stringer")
+}
+
+func (ft *FlagType) GenerateFlagInterface() bool {
+	return ft.skipInterfaceNamed("Flag")
+}
+
+func (ft *FlagType) skipInterfaceNamed(name string) bool {
+	if ft.Config == nil {
+		return true
+	}
+
+	lowName := strings.ToLower(name)
+
+	for _, interfaceName := range ft.Config.SkipInterfaces {
+		if strings.ToLower(interfaceName) == lowName {
+			return false
+		}
+	}
+
+	return true
+}

internal/genflags/spec_test.go

@@ -0,0 +1,112 @@
+package genflags_test
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/urfave/cli/v2/internal/genflags"
+)
+
+func TestSpec_SortedFlagTypes(t *testing.T) {
+	spec := &genflags.Spec{
+		FlagTypes: map[string]*genflags.FlagTypeConfig{
+			"nerf": &genflags.FlagTypeConfig{},
+			"gerf": nil,
+		},
+	}
+
+	actual := spec.SortedFlagTypes()
+	expected := []*genflags.FlagType{
+		{
+			GoType: "gerf",
+			Config: nil,
+		},
+		{
+			GoType: "nerf",
+			Config: &genflags.FlagTypeConfig{},
+		},
+	}
+	if !reflect.DeepEqual(expected, actual) {
+		t.Errorf("expected %#v, got %#v", expected, actual)
+	}
+}
+
+func genFlagType() *genflags.FlagType {
+	return &genflags.FlagType{
+		GoType: "blerf",
+		Config: &genflags.FlagTypeConfig{
+			SkipInterfaces: []string{"fmt.Stringer"},
+			StructFields: []*genflags.FlagStructField{
+				{
+					Name: "Foibles",
+					Type: "int",
+				},
+				{
+					Name: "Hoopled",
+					Type: "bool",
+				},
+			},
+			TypeName:     "YeOldeBlerfFlag",
+			ValuePointer: true,
+		},
+	}
+}
+
+func TestFlagType_StructFields(t *testing.T) {
+	ft := genFlagType()
+
+	sf := ft.StructFields()
+	if 2 != len(sf) {
+		t.Errorf("expected 2 struct fields, got %v", len(sf))
+		return
+	}
+
+	if "Foibles" != sf[0].Name {
+		t.Errorf("expected struct field order to be retained")
+	}
+}
+
+func TestFlagType_ValuePointer(t *testing.T) {
+	ft := genFlagType()
+
+	if !ft.ValuePointer() {
+		t.Errorf("expected ValuePointer to be true")
+		return
+	}
+
+	ft.Config = nil
+
+	if ft.ValuePointer() {
+		t.Errorf("expected ValuePointer to be false")
+	}
+}
+
+func TestFlagType_GenerateFmtStringerInterface(t *testing.T) {
+	ft := genFlagType()
+
+	if ft.GenerateFmtStringerInterface() {
+		t.Errorf("expected GenerateFmtStringerInterface to be false")
+		return
+	}
+
+	ft.Config = nil
+
+	if !ft.GenerateFmtStringerInterface() {
+		t.Errorf("expected GenerateFmtStringerInterface to be true")
+	}
+}
+
+func TestFlagType_GenerateFlagInterface(t *testing.T) {
+	ft := genFlagType()
+
+	if !ft.GenerateFlagInterface() {
+		t.Errorf("expected GenerateFlagInterface to be true")
+		return
+	}
+
+	ft.Config = nil
+
+	if !ft.GenerateFlagInterface() {
+		t.Errorf("expected GenerateFlagInterface to be true")
+	}
+}

testdata/empty.yml

@@ -0,0 +1 @@
+# empty file

zz_generated.flags.go

@@ -0,0 +1,507 @@
+// WARNING: this file is generated. DO NOT EDIT
+
+package cli
+
+import "time"
+
+// Float64SliceFlag is a flag with type *Float64Slice
+type Float64SliceFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       *Float64Slice
+	Destination *Float64Slice
+
+	Aliases []string
+	EnvVars []string
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Float64SliceFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *Float64SliceFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// GenericFlag is a flag with type Generic
+type GenericFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       Generic
+	Destination *Generic
+
+	Aliases []string
+	EnvVars []string
+
+	TakesFile bool
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *GenericFlag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *GenericFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *GenericFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// Int64SliceFlag is a flag with type *Int64Slice
+type Int64SliceFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       *Int64Slice
+	Destination *Int64Slice
+
+	Aliases []string
+	EnvVars []string
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Int64SliceFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *Int64SliceFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// IntSliceFlag is a flag with type *IntSlice
+type IntSliceFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       *IntSlice
+	Destination *IntSlice
+
+	Aliases []string
+	EnvVars []string
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *IntSliceFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *IntSliceFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// PathFlag is a flag with type Path
+type PathFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       Path
+	Destination *Path
+
+	Aliases []string
+	EnvVars []string
+
+	TakesFile bool
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *PathFlag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *PathFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *PathFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// StringSliceFlag is a flag with type *StringSlice
+type StringSliceFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       *StringSlice
+	Destination *StringSlice
+
+	Aliases []string
+	EnvVars []string
+
+	TakesFile bool
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *StringSliceFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *StringSliceFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// TimestampFlag is a flag with type *Timestamp
+type TimestampFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       *Timestamp
+	Destination *Timestamp
+
+	Aliases []string
+	EnvVars []string
+
+	Layout string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *TimestampFlag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *TimestampFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *TimestampFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// BoolFlag is a flag with type bool
+type BoolFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       bool
+	Destination *bool
+
+	Aliases []string
+	EnvVars []string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *BoolFlag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *BoolFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *BoolFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// Float64Flag is a flag with type float64
+type Float64Flag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       float64
+	Destination *float64
+
+	Aliases []string
+	EnvVars []string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *Float64Flag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Float64Flag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *Float64Flag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// IntFlag is a flag with type int
+type IntFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       int
+	Destination *int
+
+	Aliases []string
+	EnvVars []string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *IntFlag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *IntFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *IntFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// Int64Flag is a flag with type int64
+type Int64Flag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       int64
+	Destination *int64
+
+	Aliases []string
+	EnvVars []string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *Int64Flag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Int64Flag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *Int64Flag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// StringFlag is a flag with type string
+type StringFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       string
+	Destination *string
+
+	Aliases []string
+	EnvVars []string
+
+	TakesFile bool
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *StringFlag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *StringFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *StringFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// DurationFlag is a flag with type time.Duration
+type DurationFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       time.Duration
+	Destination *time.Duration
+
+	Aliases []string
+	EnvVars []string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *DurationFlag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *DurationFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *DurationFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// UintFlag is a flag with type uint
+type UintFlag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       uint
+	Destination *uint
+
+	Aliases []string
+	EnvVars []string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *UintFlag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *UintFlag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *UintFlag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// Uint64Flag is a flag with type uint64
+type Uint64Flag struct {
+	Name string
+
+	DefaultText string
+	FilePath    string
+	Usage       string
+
+	Required   bool
+	Hidden     bool
+	HasBeenSet bool
+
+	Value       uint64
+	Destination *uint64
+
+	Aliases []string
+	EnvVars []string
+}
+
+// String returns a readable representation of this value (for usage defaults)
+func (f *Uint64Flag) String() string {
+	return FlagStringer(f)
+}
+
+// IsSet returns whether or not the flag has been set through env or file
+func (f *Uint64Flag) IsSet() bool {
+	return f.HasBeenSet
+}
+
+// Names returns the names of the flag
+func (f *Uint64Flag) Names() []string {
+	return FlagNames(f.Name, f.Aliases)
+}
+
+// vim:ro

zz_generated.flags_test.go

@@ -0,0 +1,183 @@
+// WARNING: this file is generated. DO NOT EDIT
+
+package cli_test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/urfave/cli/v2"
+)
+
+func TestFloat64SliceFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.Float64SliceFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestGenericFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.GenericFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestGenericFlag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.GenericFlag{}
+
+	_ = f.String()
+}
+
+func TestInt64SliceFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.Int64SliceFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestIntSliceFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.IntSliceFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestPathFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.PathFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestPathFlag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.PathFlag{}
+
+	_ = f.String()
+}
+
+func TestStringSliceFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.StringSliceFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestTimestampFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.TimestampFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestTimestampFlag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.TimestampFlag{}
+
+	_ = f.String()
+}
+
+func TestBoolFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.BoolFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestBoolFlag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.BoolFlag{}
+
+	_ = f.String()
+}
+
+func TestFloat64Flag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.Float64Flag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestFloat64Flag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.Float64Flag{}
+
+	_ = f.String()
+}
+
+func TestIntFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.IntFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestIntFlag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.IntFlag{}
+
+	_ = f.String()
+}
+
+func TestInt64Flag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.Int64Flag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestInt64Flag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.Int64Flag{}
+
+	_ = f.String()
+}
+
+func TestStringFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.StringFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestStringFlag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.StringFlag{}
+
+	_ = f.String()
+}
+
+func TestDurationFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.DurationFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestDurationFlag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.DurationFlag{}
+
+	_ = f.String()
+}
+
+func TestUintFlag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.UintFlag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestUintFlag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.UintFlag{}
+
+	_ = f.String()
+}
+
+func TestUint64Flag_SatisfiesFlagInterface(t *testing.T) {
+	var f cli.Flag = &cli.Uint64Flag{}
+
+	_ = f.IsSet()
+	_ = f.Names()
+}
+
+func TestUint64Flag_SatisfiesFmtStringerInterface(t *testing.T) {
+	var f fmt.Stringer = &cli.Uint64Flag{}
+
+	_ = f.String()
+}
+
+// vim:ro