-
Notifications
You must be signed in to change notification settings - Fork 7
/
flag_value_types.go
114 lines (95 loc) · 2.3 KB
/
flag_value_types.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
package config
import (
"flag"
"fmt"
"regexp"
"sort"
"strings"
"github.com/Antonboom/testifylint/internal/checkers"
)
var (
_ flag.Value = (*KnownCheckersValue)(nil)
_ flag.Value = (*RegexpValue)(nil)
_ flag.Value = (*EnumValue[checkers.SuiteExtraAssertCallMode])(nil)
)
// KnownCheckersValue implements comma separated list of testify checkers.
type KnownCheckersValue []string
func (kcv KnownCheckersValue) String() string {
return strings.Join(kcv, ",")
}
func (kcv *KnownCheckersValue) Set(v string) error {
chckrs := strings.Split(v, ",")
for _, checkerName := range chckrs {
if ok := checkers.IsKnown(checkerName); !ok {
return fmt.Errorf("unknown checker %q", checkerName)
}
}
*kcv = chckrs
return nil
}
func (kcv KnownCheckersValue) Contains(v string) bool {
for _, checker := range kcv {
if checker == v {
return true
}
}
return false
}
// RegexpValue is a special wrapper for support of flag.FlagSet over regexp.Regexp.
// Original regexp is available through RegexpValue.Regexp.
type RegexpValue struct {
*regexp.Regexp
}
func (rv RegexpValue) String() string {
if rv.Regexp == nil {
return ""
}
return rv.Regexp.String()
}
func (rv *RegexpValue) Set(v string) error {
compiled, err := regexp.Compile(v)
if err != nil {
return err
}
rv.Regexp = compiled
return nil
}
// EnumValue is a special type for support of flag.FlagSet over user-defined constants.
type EnumValue[EnumT comparable] struct {
mapping map[string]EnumT
keys []string
dst *EnumT
}
// NewEnumValue takes the "enum-value-name to enum-value" mapping and a destination for the value passed through the CLI.
// Returns an EnumValue instance suitable for flag.FlagSet.Var.
func NewEnumValue[EnumT comparable](mapping map[string]EnumT, dst *EnumT) *EnumValue[EnumT] {
keys := make([]string, 0, len(mapping))
for k := range mapping {
keys = append(keys, k)
}
sort.Strings(keys)
return &EnumValue[EnumT]{
mapping: mapping,
keys: keys,
dst: dst,
}
}
func (e EnumValue[EnumT]) String() string {
if e.dst == nil {
return ""
}
for k, v := range e.mapping {
if v == *e.dst {
return k
}
}
return ""
}
func (e *EnumValue[EnumT]) Set(s string) error {
v, ok := e.mapping[s]
if !ok {
return fmt.Errorf("use one of (%v)", strings.Join(e.keys, " | "))
}
*e.dst = v
return nil
}