adding alias support to remaining flags and fixing tests

altsrc/flag.go

@@ -64,14 +64,18 @@ func InitInputSourceWithContext(flags []cli.Flag, createInputSource func(cCtx *c
 
 // ApplyInputSourceValue applies a generic value to the flagSet if required
 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) {
+	if f.set != nil && !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
-		value, err := isc.Generic(f.GenericFlag.Name)
+		for _, name := range f.GenericFlag.Names() {
+			if isc.isSet(name) {
+				value, err := isc.Generic(name)
 				if err != nil {
 					return err
 				}
 				if value != nil {
-			for _, name := range f.Names() {
+					for _, n := range f.Names() {
-				_ = f.set.Set(name, value.String())
+						_ = f.set.Set(n, value.String())
+					}
+				}
 			}
 		}
 	}
@@ -81,41 +85,49 @@ func (f *GenericFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceCo
 
 // ApplyInputSourceValue applies a StringSlice value to the flagSet if required
 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) {
+	if f.set != nil && !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars){
-		value, err := isc.StringSlice(f.StringSliceFlag.Name)
+		for _, name := range f.StringSliceFlag.Names() {
+			if isc.isSet(name) {
+				value, err := isc.StringSlice(name)
 				if err != nil {
 					return err
 				}
 				if value != nil {
-			var sliceValue cli.StringSlice = *(cli.NewStringSlice(value...))
+					var sliceValue = *(cli.NewStringSlice(value...))
-			for _, name := range f.Names() {
+					for _, n := range f.Names() {
-				underlyingFlag := f.set.Lookup(name)
+						underlyingFlag := f.set.Lookup(n)
 						if underlyingFlag != nil {
 							underlyingFlag.Value = &sliceValue
 						}
 					}
 				}
 			}
+		}
+	}
 	return nil
 }
 
 // ApplyInputSourceValue applies a IntSlice value if required
 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) {
+	if f.set != nil && !cCtx.IsSet(f.Name) && !isEnvVarSet(f.EnvVars) {
-		value, err := isc.IntSlice(f.IntSliceFlag.Name)
+		for _, name := range f.IntSliceFlag.Names() {
+			if isc.isSet(name) {
+				value, err := isc.IntSlice(name)
 				if err != nil {
 					return err
 				}
 				if value != nil {
-			var sliceValue cli.IntSlice = *(cli.NewIntSlice(value...))
+					var sliceValue = *(cli.NewIntSlice(value...))
-			for _, name := range f.Names() {
+					for _, n := range f.Names() {
-				underlyingFlag := f.set.Lookup(name)
+						underlyingFlag := f.set.Lookup(n)
 						if underlyingFlag != nil {
 							underlyingFlag.Value = &sliceValue
 						}
 					}
 				}
 			}
+		}
+	}
 	return nil
 }
 
@@ -160,12 +172,14 @@ func (f *StringFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceCon
 // ApplyInputSourceValue applies a Path value to the flagSet if required
 func (f *PathFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceContext) error {
 	if f.set != nil && !(cCtx.IsSet(f.Name) || isEnvVarSet(f.EnvVars)) {
-		value, err := isc.String(f.PathFlag.Name)
+		for _, name := range f.PathFlag.Names() {
+			if isc.isSet(name) {
+				value, err := isc.String(name)
 				if err != nil {
 					return err
 				}
 				if value != "" {
-			for _, name := range f.Names() {
+					for _, n := range f.Names() {
 
 						if !filepath.IsAbs(value) && isc.Source() != "" {
 							basePathAbs, err := filepath.Abs(isc.Source())
@@ -176,7 +190,9 @@ func (f *PathFlag) ApplyInputSourceValue(cCtx *cli.Context, isc InputSourceConte
 							value = filepath.Join(filepath.Dir(basePathAbs), value)
 						}
 
-				_ = f.set.Set(name, value)
+						_ = f.set.Set(n, value)
+					}
+				}
 			}
 		}
 	}

altsrc/flag_test.go

@@ -37,6 +37,20 @@ func (ris *racyInputSource) isSet(name string) bool {
 	return true
 }
 
+func TestGenericApplyInputSourceValue_Alias(t *testing.T) {
+	v := &Parser{"abc", "def"}
+	tis := testApplyInputSource{
+		Flag:     NewGenericFlag(&cli.GenericFlag{Name: "test",  Aliases: []string{"test_alias"}, Value: &Parser{}}),
+		FlagName: "test_alias",
+		MapValue: v,
+	}
+	c := runTest(t, tis)
+	expect(t, v, c.Generic("test_alias"))
+
+	c = runRacyTest(t, tis)
+	refute(t, v, c.Generic("test_alias"))
+}
+
 func TestGenericApplyInputSourceValue(t *testing.T) {
 	v := &Parser{"abc", "def"}
 	tis := testApplyInputSource{
@@ -85,6 +99,19 @@ func TestGenericApplyInputSourceMethodEnvVarSet(t *testing.T) {
 	refute(t, &Parser{"abc", "def"}, c.Generic("test"))
 }
 
+func TestStringSliceApplyInputSourceValue_Alias(t *testing.T) {
+	tis := testApplyInputSource{
+		Flag:     NewStringSliceFlag(&cli.StringSliceFlag{Name: "test", Aliases: []string{"test_alias"}}),
+		FlagName: "test_alias",
+		MapValue: []interface{}{"hello", "world"},
+	}
+	c := runTest(t, tis)
+	expect(t, c.StringSlice("test_alias"), []string{"hello", "world"})
+
+	c = runRacyTest(t, tis)
+	refute(t, c.StringSlice("test_alias"), []string{"hello", "world"})
+}
+
 func TestStringSliceApplyInputSourceValue(t *testing.T) {
 	tis := testApplyInputSource{
 		Flag:     NewStringSliceFlag(&cli.StringSliceFlag{Name: "test"}),
@@ -123,6 +150,19 @@ func TestStringSliceApplyInputSourceMethodEnvVarSet(t *testing.T) {
 	refute(t, c.StringSlice("test"), []string{"oh", "no"})
 }
 
+func TestIntSliceApplyInputSourceValue_Alias(t *testing.T) {
+	tis := testApplyInputSource{
+		Flag:     NewIntSliceFlag(&cli.IntSliceFlag{Name: "test", Aliases: []string{"test_alias"}}),
+		FlagName: "test_alias",
+		MapValue: []interface{}{1, 2},
+	}
+	c := runTest(t, tis)
+	expect(t, c.IntSlice("test_alias"), []int{1, 2})
+
+	c = runRacyTest(t, tis)
+	refute(t, c.IntSlice("test_alias"), []int{1, 2})
+}
+
 func TestIntSliceApplyInputSourceValue(t *testing.T) {
 	tis := testApplyInputSource{
 		Flag:     NewIntSliceFlag(&cli.IntSliceFlag{Name: "test"}),
@@ -276,6 +316,31 @@ func TestStringApplyInputSourceMethodEnvVarSet(t *testing.T) {
 	refute(t, "goodbye", c.String("test"))
 }
 
+func TestPathApplyInputSourceMethodSet_Alias(t *testing.T) {
+	tis := testApplyInputSource{
+		Flag:       NewPathFlag(&cli.PathFlag{Name: "test", Aliases: []string{"test_alias"}}),
+		FlagName:   "test_alias",
+		MapValue:   "hello",
+		SourcePath: "/path/to/source/file",
+	}
+	c := runTest(t, tis)
+
+	expected := "/path/to/source/hello"
+	if runtime.GOOS == "windows" {
+		var err error
+		// Prepend the corresponding drive letter (or UNC path?), and change
+		// to windows-style path:
+		expected, err = filepath.Abs(expected)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+	expect(t, expected, c.String("test_alias"))
+
+	c = runRacyTest(t, tis)
+	refute(t, expected, c.String("test_alias"))
+}
+
 func TestPathApplyInputSourceMethodSet(t *testing.T) {
 	tis := testApplyInputSource{
 		Flag:       NewPathFlag(&cli.PathFlag{Name: "test"}),
@@ -335,7 +400,7 @@ func TestPathApplyInputSourceMethodEnvVarSet(t *testing.T) {
 func TestIntApplyInputSourceMethodSet_Alias(t *testing.T) {
 	tis := testApplyInputSource{
 		Flag:     NewIntFlag(&cli.IntFlag{Name: "test", Aliases: []string{"test_alias"}}),
-		FlagName: "test",
+		FlagName: "test_alias",
 		MapValue: 15,
 	}
 	c := runTest(t, tis)
@@ -403,7 +468,7 @@ func TestIntApplyInputSourceMethodEnvVarSet(t *testing.T) {
 func TestDurationApplyInputSourceMethodSet_Alias(t *testing.T) {
 	tis := testApplyInputSource{
 		Flag:     NewDurationFlag(&cli.DurationFlag{Name: "test", Aliases: []string{"test_alias"}}),
-		FlagName: "test",
+		FlagName: "test_alias",
 		MapValue: 30 * time.Second,
 	}
 	c := runTest(t, tis)
@@ -484,7 +549,7 @@ func TestFloat64ApplyInputSourceMethodSet(t *testing.T) {
 func TestFloat64ApplyInputSourceMethodSetNegativeValue_Alias(t *testing.T) {
 	tis := testApplyInputSource{
 		Flag:     NewFloat64Flag(&cli.Float64Flag{Name: "test", Aliases: []string{"test_alias"}}),
-		FlagName: "test",
+		FlagName: "test_alias",
 		MapValue: -1.3,
 	}
 	c := runTest(t, tis)