Skip to content

Commit 31499aa

Browse files
authored
Merge pull request #2460 from MohammediYunus/fix/generic-typed-callbacks
fix: handle payload getters in GenericFlag
2 parents 046e01a + 341fa22 commit 31499aa

3 files changed

Lines changed: 277 additions & 6 deletions

File tree

‎flag_generic.go‎

Lines changed: 10 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -55,9 +55,16 @@ func (f *genericValue) IsBoolFlag() bool {
5555
// Generic looks up the value of a local GenericFlag, returns
5656
// nil if not found
5757
func (cmd *Command) Generic(name string) Value {
58-
if v, ok := cmd.Value(name).(Value); ok {
59-
tracef("generic available for flag name %[1]q with value=%[2]v (cmd=%[3]q)", name, v, cmd.Name)
60-
return v
58+
if fl := cmd.lookupFlag(name); fl != nil {
59+
if v, ok := fl.Get().(Value); ok {
60+
tracef("generic available for flag name %[1]q with value=%[2]v (cmd=%[3]q)", name, v, cmd.Name)
61+
return v
62+
}
63+
if fl, ok := fl.(*GenericFlag); ok {
64+
if value, ok := fl.value.(*genericValue); ok {
65+
return value.val
66+
}
67+
}
6168
}
6269

6370
tracef("generic NOT available for flag name %[1]q (cmd=%[2]q)", name, cmd.Name)

‎flag_generic_test.go‎

Lines changed: 248 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,248 @@
1+
package cli
2+
3+
import (
4+
"context"
5+
"errors"
6+
"flag"
7+
"testing"
8+
9+
"github.com/stretchr/testify/require"
10+
)
11+
12+
type genericPayloadValue struct {
13+
text string
14+
gets int
15+
result Value
16+
setError error
17+
}
18+
19+
func (v *genericPayloadValue) String() string { return v.text }
20+
21+
func (v *genericPayloadValue) Set(s string) error {
22+
if v.setError != nil {
23+
return v.setError
24+
}
25+
v.text = s
26+
return nil
27+
}
28+
29+
func (v *genericPayloadValue) Get() any {
30+
v.gets++
31+
if v.result != nil {
32+
return v.result
33+
}
34+
return v.text
35+
}
36+
37+
var _ Value = (*genericPayloadValue)(nil)
38+
39+
func TestGenericFlagTypedCallbacks(t *testing.T) {
40+
for _, tc := range []struct {
41+
name string
42+
make func() (Value, Value)
43+
}{
44+
{"payload", func() (Value, Value) {
45+
v := &genericPayloadValue{text: "before"}
46+
return v, v
47+
}},
48+
{"standard Getter", func() (Value, Value) {
49+
fs := flag.NewFlagSet("example", flag.ContinueOnError)
50+
fs.String("text", "before", "")
51+
v := fs.Lookup("text").Value.(Value)
52+
return v, v
53+
}},
54+
{"self", func() (Value, Value) {
55+
v := &Parser{"before", "value"}
56+
return v, v
57+
}},
58+
{"delegated Value", func() (Value, Value) {
59+
result := &Parser{"delegated", "value"}
60+
return &genericPayloadValue{result: result}, result
61+
}},
62+
} {
63+
for _, mode := range []string{"default", "set", "action"} {
64+
t.Run(tc.name+"/"+mode, func(t *testing.T) {
65+
value, want := tc.make()
66+
calls := 0
67+
observe := func(got Value) error {
68+
calls++
69+
require.Same(t, want, got)
70+
return nil
71+
}
72+
fl := &GenericFlag{Name: "value", Value: value}
73+
if mode == "action" {
74+
fl.Action = func(_ context.Context, _ *Command, got Value) error { return observe(got) }
75+
} else {
76+
fl.Validator = observe
77+
fl.ValidateDefaults = mode == "default"
78+
}
79+
require.NotPanics(t, func() {
80+
require.NoError(t, fl.PreParse())
81+
if mode != "default" {
82+
require.NoError(t, fl.Set("value", "hello,world"))
83+
}
84+
if mode == "action" {
85+
require.NoError(t, fl.RunAction(buildTestContext(t), &Command{}))
86+
}
87+
})
88+
require.Equal(t, 1, calls)
89+
if counted, ok := value.(*genericPayloadValue); ok {
90+
require.Equal(t, 1, counted.gets)
91+
}
92+
})
93+
}
94+
}
95+
}
96+
97+
func TestGenericFlagPayloadRetrieval(t *testing.T) {
98+
v := &genericPayloadValue{text: "before"}
99+
fl := &GenericFlag{Name: "value", Aliases: []string{"v"}, Value: v}
100+
cmd := &Command{Flags: []Flag{fl}}
101+
102+
// Before parsing, Get returns the declared default without invoking its Getter.
103+
require.Same(t, v, fl.Get())
104+
require.Same(t, v, cmd.Value("value"))
105+
require.Same(t, v, cmd.Generic("v"))
106+
require.Zero(t, v.gets)
107+
108+
require.NoError(t, fl.Set("value", "after"))
109+
for _, name := range []string{"value", "v"} {
110+
before := v.gets
111+
require.Same(t, v, cmd.Generic(name))
112+
require.Equal(t, before+1, v.gets)
113+
require.Equal(t, "after", cmd.Value(name))
114+
}
115+
require.Equal(t, "after", fl.Get())
116+
117+
// A Getter that already returns another Value must retain that result.
118+
other := &Parser{"other", "value"}
119+
v.result = other
120+
before := v.gets
121+
require.Same(t, other, cmd.Generic("value"))
122+
require.Equal(t, before+1, v.gets)
123+
require.Same(t, other, cmd.Value("value"))
124+
require.Same(t, other, fl.Get())
125+
}
126+
127+
func TestGenericFlagPayloadLookup(t *testing.T) {
128+
v := &genericPayloadValue{text: "parent"}
129+
fl := &GenericFlag{Name: "value", Aliases: []string{"v"}, Value: v}
130+
invalidCalls := 0
131+
parent := &Command{
132+
Flags: []Flag{fl},
133+
InvalidFlagAccessHandler: func(_ context.Context, _ *Command, name string) {
134+
invalidCalls++
135+
require.Equal(t, "missing", name)
136+
},
137+
}
138+
child := &Command{parent: parent}
139+
require.NoError(t, fl.PreParse())
140+
require.Same(t, v, child.Generic("value"))
141+
require.Same(t, v, child.Generic("v"))
142+
require.Equal(t, 2, v.gets)
143+
144+
// A local flag shadows its ancestor even when it is not a GenericFlag.
145+
child.Flags = []Flag{&StringFlag{Name: "value", Aliases: []string{"v"}, Value: "child"}}
146+
require.Nil(t, child.Generic("value"))
147+
require.Nil(t, child.Generic("v"))
148+
require.Equal(t, 2, v.gets)
149+
require.Zero(t, invalidCalls)
150+
require.Nil(t, child.Generic("missing"))
151+
require.Equal(t, 1, invalidCalls)
152+
}
153+
154+
func TestGenericFlagNilValue(t *testing.T) {
155+
fl := &GenericFlag{Name: "value"}
156+
cmd := &Command{Flags: []Flag{fl}}
157+
require.Nil(t, cmd.Generic("value"))
158+
require.Nil(t, cmd.Value("value"))
159+
calls := 0
160+
fl.Validator = func(v Value) error {
161+
calls++
162+
require.Nil(t, v)
163+
return nil
164+
}
165+
fl.ValidateDefaults = true
166+
fl.Action = func(_ context.Context, _ *Command, v Value) error {
167+
calls++
168+
require.Nil(t, v)
169+
return nil
170+
}
171+
require.NotPanics(t, func() {
172+
require.NoError(t, fl.PreParse())
173+
require.NoError(t, fl.Set("value", "ignored"))
174+
require.NoError(t, fl.RunAction(buildTestContext(t), cmd))
175+
})
176+
require.Equal(t, 3, calls)
177+
require.Nil(t, cmd.Generic("value"))
178+
require.Nil(t, cmd.Value("value"))
179+
require.Nil(t, fl.Get())
180+
}
181+
182+
func TestGenericFlagPayloadCallbackErrors(t *testing.T) {
183+
for _, mode := range []string{"default", "set", "action"} {
184+
t.Run(mode, func(t *testing.T) {
185+
failure := errors.New("callback rejected value")
186+
v := &genericPayloadValue{}
187+
fl := &GenericFlag{Name: "value", Value: v}
188+
if mode == "action" {
189+
fl.Action = func(context.Context, *Command, Value) error { return failure }
190+
} else {
191+
fl.Validator = func(Value) error { return failure }
192+
fl.ValidateDefaults = mode == "default"
193+
}
194+
require.NotPanics(t, func() {
195+
if mode == "default" {
196+
require.ErrorIs(t, fl.PreParse(), failure)
197+
return
198+
}
199+
require.NoError(t, fl.PreParse())
200+
if mode == "set" {
201+
require.ErrorIs(t, fl.Set("value", "text"), failure)
202+
} else {
203+
require.ErrorIs(t, fl.RunAction(buildTestContext(t), &Command{}), failure)
204+
}
205+
})
206+
})
207+
}
208+
209+
t.Run("Set error precedes validation", func(t *testing.T) {
210+
failure := errors.New("cannot parse value")
211+
v := &genericPayloadValue{setError: failure}
212+
fl := &GenericFlag{Name: "value", Value: v, Validator: func(Value) error {
213+
t.Fatal("validator ran after Set failed")
214+
return nil
215+
}}
216+
require.ErrorIs(t, fl.Set("value", "text"), failure)
217+
require.Zero(t, v.gets)
218+
})
219+
}
220+
221+
func TestGenericFlagPayloadCommandRun(t *testing.T) {
222+
for _, args := range [][]string{{"app"}, {"app", "--value", "hello"}} {
223+
t.Run(args[len(args)-1], func(t *testing.T) {
224+
v := &genericPayloadValue{}
225+
var calls []string
226+
cmd := &Command{Flags: []Flag{&GenericFlag{
227+
Name: "value", Value: v,
228+
Validator: func(got Value) error {
229+
require.Same(t, v, got)
230+
calls = append(calls, "validator")
231+
return nil
232+
},
233+
Action: func(_ context.Context, _ *Command, got Value) error {
234+
require.Same(t, v, got)
235+
calls = append(calls, "action")
236+
return nil
237+
},
238+
}}}
239+
require.NotPanics(t, func() { require.NoError(t, cmd.Run(buildTestContext(t), args)) })
240+
if len(args) == 1 {
241+
require.Empty(t, calls)
242+
} else {
243+
require.Equal(t, []string{"validator", "action"}, calls)
244+
require.Equal(t, "hello", v.text)
245+
}
246+
})
247+
}
248+
}

‎flag_impl.go‎

Lines changed: 19 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -191,12 +191,28 @@ func (f *FlagBase[T, C, V]) newValue() Value {
191191
return f.creator.Create(f.Value, f.Destination, f.Config)
192192
}
193193

194+
func (f *FlagBase[T, C, V]) getTypedValue() T {
195+
value := f.value.Get()
196+
if typed, ok := value.(T); ok {
197+
return typed
198+
}
199+
// A GenericFlag's Getter may expose a payload rather than a cli.Value.
200+
if generic, ok := f.value.(*genericValue); ok {
201+
var typed T
202+
if generic.val != nil {
203+
typed = any(generic.val).(T)
204+
}
205+
return typed
206+
}
207+
return value.(T)
208+
}
209+
194210
func (f *FlagBase[T, C, V]) PreParse() error {
195211
f.value = f.newValue()
196212

197213
// Validate the given default or values set from external sources as well
198214
if f.Validator != nil && f.ValidateDefaults {
199-
if err := f.Validator(f.value.Get().(T)); err != nil {
215+
if err := f.Validator(f.getTypedValue()); err != nil {
200216
return err
201217
}
202218
}
@@ -244,7 +260,7 @@ func (f *FlagBase[T, C, V]) Set(_ string, val string) error {
244260
}
245261
f.hasBeenSet = true
246262
if f.Validator != nil {
247-
if err := f.Validator(f.value.Get().(T)); err != nil {
263+
if err := f.Validator(f.getTypedValue()); err != nil {
248264
return err
249265
}
250266
}
@@ -337,7 +353,7 @@ func (f *FlagBase[T, C, V]) GetDefaultText() string {
337353
// RunAction executes flag action if set
338354
func (f *FlagBase[T, C, V]) RunAction(ctx context.Context, cmd *Command) error {
339355
if f.Action != nil {
340-
return f.Action(ctx, cmd, f.value.Get().(T))
356+
return f.Action(ctx, cmd, f.getTypedValue())
341357
}
342358

343359
return nil

0 commit comments

Comments
 (0)