diff options
| author | Dave Henderson <dhenderson@gmail.com> | 2025-03-09 20:14:46 -0400 |
|---|---|---|
| committer | GitHub <noreply@github.com> | 2025-03-10 00:14:46 +0000 |
| commit | bfa6b9dcef7592e6dd8225aaa0d0ab5aef5b3f84 (patch) | |
| tree | 7e844defee92dc3af320df20baa6f9b421d4a4c9 /internal | |
| parent | 7942441e61471f578a57910b3aa93636f5a0310d (diff) | |
chore(refactoring): Refactor/modernizations (#2345)
chore(refactoring): Refactor with modernization refactorings
* range over int
* replace interface{} with any
* replace common map operations with maps.Copy/maps.Clone
* simplifying loops with slices.Contains/ContainsFunc
* modernize benchmarks with b.Loop
* modernize tests with t.Context
* use fmt.Appendf
* range over strings.SplitSeq
* use new stdlib crypto/pbkdf2 package
---------
Signed-off-by: Dave Henderson <dhenderson@gmail.com>
Diffstat (limited to 'internal')
60 files changed, 639 insertions, 650 deletions
diff --git a/internal/cmd/main_test.go b/internal/cmd/main_test.go index 6225e932..58519d6c 100644 --- a/internal/cmd/main_test.go +++ b/internal/cmd/main_test.go @@ -2,7 +2,6 @@ package cmd import ( "bytes" - "context" "strings" "testing" @@ -42,8 +41,7 @@ func TestOptionalExecArgs(t *testing.T) { } func TestRunMain(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() + ctx := t.Context() err := Main(ctx, []string{"-h"}, nil, nil, nil) require.NoError(t, err) @@ -60,8 +58,7 @@ func TestRunMain(t *testing.T) { } func TestPostRunExec(t *testing.T) { - ctx, cancel := context.WithCancel(context.Background()) - defer cancel() + ctx := t.Context() out := &bytes.Buffer{} err := postRunExec(ctx, []string{"cat"}, strings.NewReader("hello world"), out, out) diff --git a/internal/config/types.go b/internal/config/types.go index 022363f7..083b1c1e 100644 --- a/internal/config/types.go +++ b/internal/config/types.go @@ -73,7 +73,7 @@ func (t *Templates) unmarshalYAMLArray(value *yaml.Node) error { return nil } -func (t Templates) MarshalYAML() (interface{}, error) { +func (t Templates) MarshalYAML() (any, error) { type rawTemplate struct { Header http.Header `yaml:"header,omitempty,flow"` URL string `yaml:"url"` @@ -133,7 +133,7 @@ func (d *DataSource) UnmarshalYAML(value *yaml.Node) error { // MarshalYAML - satisfy the yaml.Marshaler interface - URLs aren't // well supported, and anyway we need to do some extra parsing -func (d DataSource) MarshalYAML() (interface{}, error) { +func (d DataSource) MarshalYAML() (any, error) { type raw struct { Header http.Header URL string diff --git a/internal/conv/conv.go b/internal/conv/conv.go index 3b2ca7c7..29dca28e 100644 --- a/internal/conv/conv.go +++ b/internal/conv/conv.go @@ -5,11 +5,11 @@ import ( "reflect" ) -// InterfaceSlice converts an array or slice of any type into an []interface{} +// InterfaceSlice converts an array or slice of any type into an []any // for use in functions that expect this. -func InterfaceSlice(slice interface{}) ([]interface{}, error) { - // avoid all this nonsense if this is already a []interface{}... - if s, ok := slice.([]interface{}); ok { +func InterfaceSlice(slice any) ([]any, error) { + // avoid all this nonsense if this is already a []any... + if s, ok := slice.([]any); ok { return s, nil } s := reflect.ValueOf(slice) @@ -17,8 +17,8 @@ func InterfaceSlice(slice interface{}) ([]interface{}, error) { switch kind { case reflect.Slice, reflect.Array: l := s.Len() - ret := make([]interface{}, l) - for i := 0; i < l; i++ { + ret := make([]any, l) + for i := range l { ret[i] = s.Index(i).Interface() } return ret, nil diff --git a/internal/conv/conv_test.go b/internal/conv/conv_test.go index c83c8dd0..f2542383 100644 --- a/internal/conv/conv_test.go +++ b/internal/conv/conv_test.go @@ -9,14 +9,14 @@ import ( func TestInterfaceSlice(t *testing.T) { data := []struct { - in, expected interface{} + in, expected any }{ - {[]int{1, 2, 3}, []interface{}{1, 2, 3}}, - {[3]int{1, 2, 3}, []interface{}{1, 2, 3}}, - {[]string{"foo", "bar", "baz"}, []interface{}{"foo", "bar", "baz"}}, - {[3]string{"foo", "bar", "baz"}, []interface{}{"foo", "bar", "baz"}}, - {[]interface{}{[]string{}, []int{1, 2}, 3}, []interface{}{[]string{}, []int{1, 2}, 3}}, - {[3]interface{}{[]string{}, []int{1, 2}, 3}, []interface{}{[]string{}, []int{1, 2}, 3}}, + {[]int{1, 2, 3}, []any{1, 2, 3}}, + {[3]int{1, 2, 3}, []any{1, 2, 3}}, + {[]string{"foo", "bar", "baz"}, []any{"foo", "bar", "baz"}}, + {[3]string{"foo", "bar", "baz"}, []any{"foo", "bar", "baz"}}, + {[]any{[]string{}, []int{1, 2}, 3}, []any{[]string{}, []int{1, 2}, 3}}, + {[3]any{[]string{}, []int{1, 2}, 3}, []any{[]string{}, []int{1, 2}, 3}}, } for _, d := range data { @@ -30,18 +30,18 @@ func TestInterfaceSlice(t *testing.T) { } func BenchmarkInterfaceSlice(b *testing.B) { - data := []interface{}{ + data := []any{ []int{1, 2, 3}, [3]int{1, 2, 3}, []string{"foo", "bar", "baz", "foo", "bar", "baz", "foo", "bar", "baz", "foo", "bar", "baz"}, [12]string{"foo", "bar", "baz", "foo", "bar", "baz", "foo", "bar", "baz", "foo", "bar", "baz"}, - []interface{}{[]string{}, []int{1, 2}, 3}, - [3]interface{}{[]string{}, []int{1, 2}, 3}, + []any{[]string{}, []int{1, 2}, 3}, + [3]any{[]string{}, []int{1, 2}, 3}, } for _, d := range data { b.Run(fmt.Sprintf("%T(%v)", d, d), func(b *testing.B) { - for i := 0; i < b.N; i++ { + for b.Loop() { InterfaceSlice(d) } }) diff --git a/internal/datafs/envfs.go b/internal/datafs/envfs.go index 0a8d82c4..6418fcd9 100644 --- a/internal/datafs/envfs.go +++ b/internal/datafs/envfs.go @@ -194,7 +194,7 @@ func (fi staticFileInfo) Mode() fs.FileMode { return fi.mode } func (fi *staticFileInfo) ModTime() time.Time { return fi.modTime } func (fi staticFileInfo) Name() string { return fi.name } func (fi staticFileInfo) Size() int64 { return fi.size } -func (fi staticFileInfo) Sys() interface{} { return nil } +func (fi staticFileInfo) Sys() any { return nil } func (fi *staticFileInfo) Info() (fs.FileInfo, error) { return fi, nil } func (fi staticFileInfo) Type() fs.FileMode { return fi.Mode().Type() } diff --git a/internal/datafs/mergefs.go b/internal/datafs/mergefs.go index 1559b5fb..4c10fb1d 100644 --- a/internal/datafs/mergefs.go +++ b/internal/datafs/mergefs.go @@ -264,7 +264,7 @@ func (f *mergeFile) readSubFile(sf subFile) (map[string]any, error) { return sfData, nil } -func mergeData(data []map[string]interface{}) ([]byte, error) { +func mergeData(data []map[string]any) ([]byte, error) { dst := data[0] data = data[1:] diff --git a/internal/datafs/mergefs_test.go b/internal/datafs/mergefs_test.go index 012c5a95..d03c63d5 100644 --- a/internal/datafs/mergefs_test.go +++ b/internal/datafs/mergefs_test.go @@ -97,59 +97,59 @@ func wdForTest(t *testing.T) string { } func TestMergeData(t *testing.T) { - def := map[string]interface{}{ + def := map[string]any{ "f": true, "t": false, "z": "def", } - out, err := mergeData([]map[string]interface{}{def}) + out, err := mergeData([]map[string]any{def}) require.NoError(t, err) assert.Equal(t, "f: true\nt: false\nz: def\n", string(out)) - over := map[string]interface{}{ + over := map[string]any{ "f": false, "t": true, "z": "over", } - out, err = mergeData([]map[string]interface{}{over, def}) + out, err = mergeData([]map[string]any{over, def}) require.NoError(t, err) assert.Equal(t, "f: false\nt: true\nz: over\n", string(out)) - over = map[string]interface{}{ + over = map[string]any{ "f": false, "t": true, "z": "over", - "m": map[string]interface{}{ + "m": map[string]any{ "a": "aaa", }, } - out, err = mergeData([]map[string]interface{}{over, def}) + out, err = mergeData([]map[string]any{over, def}) require.NoError(t, err) assert.Equal(t, "f: false\nm:\n a: aaa\nt: true\nz: over\n", string(out)) - uber := map[string]interface{}{ + uber := map[string]any{ "z": "über", } - out, err = mergeData([]map[string]interface{}{uber, over, def}) + out, err = mergeData([]map[string]any{uber, over, def}) require.NoError(t, err) assert.Equal(t, "f: false\nm:\n a: aaa\nt: true\nz: über\n", string(out)) - uber = map[string]interface{}{ + uber = map[string]any{ "m": "notamap", - "z": map[string]interface{}{ + "z": map[string]any{ "b": "bbb", }, } - out, err = mergeData([]map[string]interface{}{uber, over, def}) + out, err = mergeData([]map[string]any{uber, over, def}) require.NoError(t, err) assert.Equal(t, "f: false\nm: notamap\nt: true\nz:\n b: bbb\n", string(out)) - uber = map[string]interface{}{ - "m": map[string]interface{}{ + uber = map[string]any{ + "m": map[string]any{ "b": "bbb", }, } - out, err = mergeData([]map[string]interface{}{uber, over, def}) + out, err = mergeData([]map[string]any{uber, over, def}) require.NoError(t, err) assert.Equal(t, "f: false\nm:\n a: aaa\n b: bbb\nt: true\nz: over\n", string(out)) } diff --git a/internal/datafs/reader_test.go b/internal/datafs/reader_test.go index 740cfa53..dbb37edc 100644 --- a/internal/datafs/reader_test.go +++ b/internal/datafs/reader_test.go @@ -127,7 +127,7 @@ func BenchmarkResolveURL(b *testing.B) { for _, a := range args { b.Run(fmt.Sprintf("base=%s_rel=%s", &a.url, a.rel), func(b *testing.B) { - for i := 0; i < b.N; i++ { + for b.Loop() { _, _ = resolveURL(a.url, a.rel) } }) diff --git a/internal/datafs/stdinfs_test.go b/internal/datafs/stdinfs_test.go index 8b0e0598..ba14483f 100644 --- a/internal/datafs/stdinfs_test.go +++ b/internal/datafs/stdinfs_test.go @@ -104,7 +104,7 @@ func TestStdinFS(t *testing.T) { ctx := ContextWithStdin(context.Background(), bytes.NewReader(content)) fsys = fsimpl.WithContextFS(ctx, fsys) - for i := 0; i < 3; i++ { + for i := range 3 { f, err := fsys.Open("foo") require.NoError(t, err) @@ -118,7 +118,7 @@ func TestStdinFS(t *testing.T) { ctx := ContextWithStdin(context.Background(), bytes.NewReader(content)) fsys = fsimpl.WithContextFS(ctx, fsys) - for i := 0; i < 3; i++ { + for i := range 3 { b, err := fs.ReadFile(fsys, "foo") require.NoError(t, err) require.Equal(t, content, b, "read %d failed", i) diff --git a/internal/funcs/aws.go b/internal/funcs/aws.go index 01e225ca..891e1a3b 100644 --- a/internal/funcs/aws.go +++ b/internal/funcs/aws.go @@ -9,15 +9,15 @@ import ( ) // CreateAWSFuncs - -func CreateAWSFuncs(ctx context.Context) map[string]interface{} { - f := map[string]interface{}{} +func CreateAWSFuncs(ctx context.Context) map[string]any { + f := map[string]any{} ns := &Funcs{ ctx: ctx, awsopts: aws.GetClientOptions(), } - f["aws"] = func() interface{} { return ns } + f["aws"] = func() any { return ns } // global aliases - for backwards compatibility f["ec2meta"] = ns.EC2Meta @@ -74,13 +74,13 @@ func (a *Funcs) EC2Tags() (map[string]string, error) { } // KMSEncrypt - -func (a *Funcs) KMSEncrypt(keyID, plaintext interface{}) (string, error) { +func (a *Funcs) KMSEncrypt(keyID, plaintext any) (string, error) { a.kmsInit.Do(a.initKMS) return a.kms.Encrypt(conv.ToString(keyID), conv.ToString(plaintext)) } // KMSDecrypt - -func (a *Funcs) KMSDecrypt(ciphertext interface{}) (string, error) { +func (a *Funcs) KMSDecrypt(ciphertext any) (string, error) { a.kmsInit.Do(a.initKMS) return a.kms.Decrypt(conv.ToString(ciphertext)) } diff --git a/internal/funcs/aws_test.go b/internal/funcs/aws_test.go index 2a1efc5d..396d7826 100644 --- a/internal/funcs/aws_test.go +++ b/internal/funcs/aws_test.go @@ -12,14 +12,14 @@ import ( func TestCreateAWSFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateAWSFuncs(ctx) - actual := fmap["aws"].(func() interface{}) + actual := fmap["aws"].(func() any) assert.Equal(t, ctx, actual().(*Funcs).ctx) }) @@ -38,7 +38,7 @@ func TestAWSFuncs(t *testing.T) { assert.Equal(t, "unknown", must(af.EC2Region())) } -func must(r interface{}, err error) interface{} { +func must(r any, err error) any { if err != nil { panic(err) } diff --git a/internal/funcs/base64.go b/internal/funcs/base64.go index ba79a1d1..b7c86657 100644 --- a/internal/funcs/base64.go +++ b/internal/funcs/base64.go @@ -8,11 +8,11 @@ import ( ) // CreateBase64Funcs - -func CreateBase64Funcs(ctx context.Context) map[string]interface{} { - f := map[string]interface{}{} +func CreateBase64Funcs(ctx context.Context) map[string]any { + f := map[string]any{} ns := &Base64Funcs{ctx} - f["base64"] = func() interface{} { return ns } + f["base64"] = func() any { return ns } return f } @@ -23,19 +23,19 @@ type Base64Funcs struct { } // Encode - -func (Base64Funcs) Encode(in interface{}) (string, error) { +func (Base64Funcs) Encode(in any) (string, error) { b := toBytes(in) return base64.Encode(b) } // Decode - -func (Base64Funcs) Decode(in interface{}) (string, error) { +func (Base64Funcs) Decode(in any) (string, error) { out, err := base64.Decode(conv.ToString(in)) return string(out), err } // DecodeBytes - -func (Base64Funcs) DecodeBytes(in interface{}) ([]byte, error) { +func (Base64Funcs) DecodeBytes(in any) ([]byte, error) { out, err := base64.Decode(conv.ToString(in)) return out, err } @@ -44,7 +44,7 @@ type byter interface { Bytes() []byte } -func toBytes(in interface{}) []byte { +func toBytes(in any) []byte { if in == nil { return []byte{} } diff --git a/internal/funcs/base64_test.go b/internal/funcs/base64_test.go index f0cca886..425a1218 100644 --- a/internal/funcs/base64_test.go +++ b/internal/funcs/base64_test.go @@ -13,14 +13,14 @@ import ( func TestCreateBase64Funcs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateBase64Funcs(ctx) - actual := fmap["base64"].(func() interface{}) + actual := fmap["base64"].(func() any) assert.Equal(t, ctx, actual().(*Base64Funcs).ctx) }) @@ -63,7 +63,7 @@ func TestToBytes(t *testing.T) { } func BenchmarkToBytes(b *testing.B) { - for i := 0; i < b.N; i++ { + for b.Loop() { b.StopTimer() buf := &bytes.Buffer{} buf.WriteString("hi") diff --git a/internal/funcs/coll.go b/internal/funcs/coll.go index 0f87239d..c32c2ba6 100644 --- a/internal/funcs/coll.go +++ b/internal/funcs/coll.go @@ -13,11 +13,11 @@ import ( ) // CreateCollFuncs - -func CreateCollFuncs(ctx context.Context) map[string]interface{} { - f := map[string]interface{}{} +func CreateCollFuncs(ctx context.Context) map[string]any { + f := map[string]any{} ns := &CollFuncs{ctx} - f["coll"] = func() interface{} { return ns } + f["coll"] = func() any { return ns } f["has"] = ns.Has f["slice"] = ns.deprecatedSlice @@ -44,13 +44,13 @@ type CollFuncs struct { } // Slice - -func (CollFuncs) Slice(args ...interface{}) []interface{} { +func (CollFuncs) Slice(args ...any) []any { return coll.Slice(args...) } // deprecatedSlice - // Deprecated: use coll.Slice instead -func (f *CollFuncs) deprecatedSlice(args ...interface{}) []interface{} { +func (f *CollFuncs) deprecatedSlice(args ...any) []any { deprecated.WarnDeprecated(f.ctx, "the 'slice' alias for coll.Slice is deprecated - use coll.Slice instead") return coll.Slice(args...) } @@ -61,7 +61,7 @@ func (CollFuncs) GoSlice(item reflect.Value, indexes ...reflect.Value) (reflect. } // Has - -func (CollFuncs) Has(in interface{}, key string) bool { +func (CollFuncs) Has(in any, key string) bool { return coll.Has(in, key) } @@ -70,7 +70,7 @@ func (CollFuncs) Has(in interface{}, key string) bool { // the arguments are ordered differently for pipeline compatibility. Also, this // function is more strict, and will return an error when the value doesn't // contain the given key. -func (CollFuncs) Index(args ...interface{}) (interface{}, error) { +func (CollFuncs) Index(args ...any) (any, error) { if len(args) < 2 { return nil, fmt.Errorf("wrong number of args: wanted at least 2, got %d", len(args)) } @@ -82,50 +82,50 @@ func (CollFuncs) Index(args ...interface{}) (interface{}, error) { } // Dict - -func (CollFuncs) Dict(in ...interface{}) (map[string]interface{}, error) { +func (CollFuncs) Dict(in ...any) (map[string]any, error) { return coll.Dict(in...) } // Keys - -func (CollFuncs) Keys(in ...map[string]interface{}) ([]string, error) { +func (CollFuncs) Keys(in ...map[string]any) ([]string, error) { return coll.Keys(in...) } // Values - -func (CollFuncs) Values(in ...map[string]interface{}) ([]interface{}, error) { +func (CollFuncs) Values(in ...map[string]any) ([]any, error) { return coll.Values(in...) } // Append - -func (CollFuncs) Append(v interface{}, list interface{}) ([]interface{}, error) { +func (CollFuncs) Append(v any, list any) ([]any, error) { return coll.Append(v, list) } // Prepend - -func (CollFuncs) Prepend(v interface{}, list interface{}) ([]interface{}, error) { +func (CollFuncs) Prepend(v any, list any) ([]any, error) { return coll.Prepend(v, list) } // Uniq - -func (CollFuncs) Uniq(in interface{}) ([]interface{}, error) { +func (CollFuncs) Uniq(in any) ([]any, error) { return coll.Uniq(in) } // Reverse - -func (CollFuncs) Reverse(in interface{}) ([]interface{}, error) { +func (CollFuncs) Reverse(in any) ([]any, error) { return coll.Reverse(in) } // Merge - -func (CollFuncs) Merge(dst map[string]interface{}, src ...map[string]interface{}) (map[string]interface{}, error) { +func (CollFuncs) Merge(dst map[string]any, src ...map[string]any) (map[string]any, error) { return coll.Merge(dst, src...) } // Sort - -func (CollFuncs) Sort(args ...interface{}) ([]interface{}, error) { +func (CollFuncs) Sort(args ...any) ([]any, error) { var ( key string - list interface{} + list any ) if len(args) == 0 || len(args) > 2 { return nil, fmt.Errorf("wrong number of args: wanted 1 or 2, got %d", len(args)) @@ -141,17 +141,17 @@ func (CollFuncs) Sort(args ...interface{}) ([]interface{}, error) { } // JSONPath - -func (CollFuncs) JSONPath(p string, in interface{}) (interface{}, error) { +func (CollFuncs) JSONPath(p string, in any) (any, error) { return coll.JSONPath(p, in) } // JQ - -func (f *CollFuncs) JQ(jqExpr string, in interface{}) (interface{}, error) { +func (f *CollFuncs) JQ(jqExpr string, in any) (any, error) { return coll.JQ(f.ctx, jqExpr, in) } // Flatten - -func (CollFuncs) Flatten(args ...interface{}) ([]interface{}, error) { +func (CollFuncs) Flatten(args ...any) ([]any, error) { if len(args) == 0 || len(args) > 2 { return nil, fmt.Errorf("wrong number of args: wanted 1 or 2, got %d", len(args)) } @@ -172,22 +172,22 @@ func (CollFuncs) Flatten(args ...interface{}) ([]interface{}, error) { return coll.Flatten(list, depth) } -func pickOmitArgs(args ...interface{}) (map[string]interface{}, []string, error) { +func pickOmitArgs(args ...any) (map[string]any, []string, error) { if len(args) <= 1 { return nil, nil, fmt.Errorf("wrong number of args: wanted 2 or more, got %d", len(args)) } - m, ok := args[len(args)-1].(map[string]interface{}) + m, ok := args[len(args)-1].(map[string]any) if !ok { - return nil, nil, fmt.Errorf("wrong map type: must be map[string]interface{}, got %T", args[len(args)-1]) + return nil, nil, fmt.Errorf("wrong map type: must be map[string]any, got %T", args[len(args)-1]) } // special-case - if there's only one key and it's a slice, expand it if len(args) == 2 { if reflect.TypeOf(args[0]).Kind() == reflect.Slice { sl := reflect.ValueOf(args[0]) - expandedArgs := make([]interface{}, sl.Len()+1) - for i := 0; i < sl.Len(); i++ { + expandedArgs := make([]any, sl.Len()+1) + for i := range sl.Len() { expandedArgs[i] = sl.Index(i).Interface() } expandedArgs[len(expandedArgs)-1] = m @@ -207,7 +207,7 @@ func pickOmitArgs(args ...interface{}) (map[string]interface{}, []string, error) } // Pick - -func (CollFuncs) Pick(args ...interface{}) (map[string]interface{}, error) { +func (CollFuncs) Pick(args ...any) (map[string]any, error) { m, keys, err := pickOmitArgs(args...) if err != nil { return nil, err @@ -216,7 +216,7 @@ func (CollFuncs) Pick(args ...interface{}) (map[string]interface{}, error) { } // Omit - -func (CollFuncs) Omit(args ...interface{}) (map[string]interface{}, error) { +func (CollFuncs) Omit(args ...any) (map[string]any, error) { m, keys, err := pickOmitArgs(args...) if err != nil { return nil, err @@ -225,14 +225,14 @@ func (CollFuncs) Omit(args ...interface{}) (map[string]interface{}, error) { } // Set - -func (CollFuncs) Set(key string, value interface{}, m map[string]interface{}) (map[string]interface{}, error) { +func (CollFuncs) Set(key string, value any, m map[string]any) (map[string]any, error) { m[key] = value return m, nil } // Unset - -func (CollFuncs) Unset(key string, m map[string]interface{}) (map[string]interface{}, error) { +func (CollFuncs) Unset(key string, m map[string]any) (map[string]any, error) { delete(m, key) return m, nil diff --git a/internal/funcs/coll_test.go b/internal/funcs/coll_test.go index b075d078..86e53e65 100644 --- a/internal/funcs/coll_test.go +++ b/internal/funcs/coll_test.go @@ -13,14 +13,14 @@ import ( func TestCreateCollFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateCollFuncs(ctx) - actual := fmap["coll"].(func() interface{}) + actual := fmap["coll"].(func() any) assert.Equal(t, ctx, actual().(*CollFuncs).ctx) }) @@ -38,13 +38,13 @@ func TestFlatten(t *testing.T) { _, err = c.Flatten(42) require.Error(t, err) - out, err := c.Flatten([]interface{}{1, []interface{}{[]int{2}, 3}}) + out, err := c.Flatten([]any{1, []any{[]int{2}, 3}}) require.NoError(t, err) - assert.EqualValues(t, []interface{}{1, 2, 3}, out) + assert.EqualValues(t, []any{1, 2, 3}, out) - out, err = c.Flatten(1, []interface{}{1, []interface{}{[]int{2}, 3}}) + out, err = c.Flatten(1, []any{1, []any{[]int{2}, 3}}) require.NoError(t, err) - assert.EqualValues(t, []interface{}{1, []int{2}, 3}, out) + assert.EqualValues(t, []any{1, []int{2}, 3}, out) } func TestPick(t *testing.T) { @@ -64,19 +64,19 @@ func TestPick(t *testing.T) { _, err = c.Pick("foo", "bar") require.Error(t, err) - _, err = c.Pick(map[string]interface{}{}, "foo", "bar", map[string]interface{}{}) + _, err = c.Pick(map[string]any{}, "foo", "bar", map[string]any{}) require.Error(t, err) - in := map[string]interface{}{ + in := map[string]any{ "foo": "bar", "bar": true, "": "baz", } out, err := c.Pick("baz", in) require.NoError(t, err) - assert.EqualValues(t, map[string]interface{}{}, out) + assert.EqualValues(t, map[string]any{}, out) - expected := map[string]interface{}{ + expected := map[string]any{ "foo": "bar", "bar": true, } @@ -84,7 +84,7 @@ func TestPick(t *testing.T) { require.NoError(t, err) assert.EqualValues(t, expected, out) - expected = map[string]interface{}{ + expected = map[string]any{ "": "baz", } out, err = c.Pick("", in) @@ -98,14 +98,14 @@ func TestPick(t *testing.T) { t.Run("supports slice key", func(t *testing.T) { t.Parallel() - in := map[string]interface{}{ + in := map[string]any{ "foo": "bar", "bar": true, "": "baz", } out, err := c.Pick([]string{"foo", "bar"}, in) require.NoError(t, err) - assert.EqualValues(t, map[string]interface{}{"foo": "bar", "bar": true}, out) + assert.EqualValues(t, map[string]any{"foo": "bar", "bar": true}, out) }) } @@ -126,10 +126,10 @@ func TestOmit(t *testing.T) { _, err = c.Omit("foo", "bar") require.Error(t, err) - _, err = c.Omit(map[string]interface{}{}, "foo", "bar", map[string]interface{}{}) + _, err = c.Omit(map[string]any{}, "foo", "bar", map[string]any{}) require.Error(t, err) - in := map[string]interface{}{ + in := map[string]any{ "foo": "bar", "bar": true, "": "baz", @@ -138,7 +138,7 @@ func TestOmit(t *testing.T) { require.NoError(t, err) assert.EqualValues(t, in, out) - expected := map[string]interface{}{ + expected := map[string]any{ "foo": "bar", "bar": true, } @@ -146,7 +146,7 @@ func TestOmit(t *testing.T) { require.NoError(t, err) assert.EqualValues(t, expected, out) - expected = map[string]interface{}{ + expected = map[string]any{ "": "baz", } out, err = c.Omit("foo", "bar", in) @@ -155,32 +155,32 @@ func TestOmit(t *testing.T) { out, err = c.Omit("foo", "bar", "", in) require.NoError(t, err) - assert.EqualValues(t, map[string]interface{}{}, out) + assert.EqualValues(t, map[string]any{}, out) t.Run("supports slice of strings", func(t *testing.T) { t.Parallel() - in := map[string]interface{}{ + in := map[string]any{ "foo": "bar", "bar": true, "": "baz", } out, err := c.Omit([]string{"foo", "bar"}, in) require.NoError(t, err) - assert.EqualValues(t, map[string]interface{}{"": "baz"}, out) + assert.EqualValues(t, map[string]any{"": "baz"}, out) }) - t.Run("supports slice of interface{}", func(t *testing.T) { + t.Run("supports slice of any", func(t *testing.T) { t.Parallel() - in := map[string]interface{}{ + in := map[string]any{ "foo": "bar", "bar": true, "": "baz", } - out, err := c.Omit([]interface{}{"foo", "bar"}, in) + out, err := c.Omit([]any{"foo", "bar"}, in) require.NoError(t, err) - assert.EqualValues(t, map[string]interface{}{"": "baz"}, out) + assert.EqualValues(t, map[string]any{"": "baz"}, out) }) } @@ -198,8 +198,8 @@ func TestGoSlice(t *testing.T) { require.Error(t, err) // invalid index type - in = reflect.ValueOf([]interface{}{1}) - _, err = c.GoSlice(in, reflect.ValueOf([]interface{}{[]int{2}})) + in = reflect.ValueOf([]any{1}) + _, err = c.GoSlice(in, reflect.ValueOf([]any{[]int{2}})) require.Error(t, err) // valid slice, no slicing @@ -222,15 +222,15 @@ func TestCollFuncs_Set(t *testing.T) { c := &CollFuncs{} - m := map[string]interface{}{"foo": "bar"} + m := map[string]any{"foo": "bar"} out, err := c.Set("foo", "baz", m) require.NoError(t, err) - assert.EqualValues(t, map[string]interface{}{"foo": "baz"}, out) + assert.EqualValues(t, map[string]any{"foo": "baz"}, out) // m was modified so foo is now baz out, err = c.Set("bar", "baz", m) require.NoError(t, err) - assert.EqualValues(t, map[string]interface{}{"foo": "baz", "bar": "baz"}, out) + assert.EqualValues(t, map[string]any{"foo": "baz", "bar": "baz"}, out) } func TestCollFuncs_Unset(t *testing.T) { @@ -238,7 +238,7 @@ func TestCollFuncs_Unset(t *testing.T) { c := &CollFuncs{} - m := map[string]interface{}{"foo": "bar"} + m := map[string]any{"foo": "bar"} out, err := c.Unset("foo", m) require.NoError(t, err) assert.Empty(t, out) diff --git a/internal/funcs/conv.go b/internal/funcs/conv.go index 67fd3b9f..5d6ba8f7 100644 --- a/internal/funcs/conv.go +++ b/internal/funcs/conv.go @@ -11,11 +11,11 @@ import ( ) // CreateConvFuncs - -func CreateConvFuncs(ctx context.Context) map[string]interface{} { +func CreateConvFuncs(ctx context.Context) map[string]any { ns := &ConvFuncs{ctx} - f := map[string]interface{}{} - f["conv"] = func() interface{} { return ns } + f := map[string]any{} + f["conv"] = func() any { return ns } f["urlParse"] = ns.URL f["bool"] = ns.Bool @@ -32,93 +32,93 @@ type ConvFuncs struct { // Bool - // // Deprecated: use [ToBool] instead -func (f *ConvFuncs) Bool(s interface{}) bool { +func (f *ConvFuncs) Bool(s any) bool { deprecated.WarnDeprecated(f.ctx, "conv.Bool is deprecated - use conv.ToBool instead") return conv.Bool(conv.ToString(s)) } // ToBool - -func (ConvFuncs) ToBool(in interface{}) bool { +func (ConvFuncs) ToBool(in any) bool { return conv.ToBool(in) } // ToBools - -func (ConvFuncs) ToBools(in ...interface{}) []bool { +func (ConvFuncs) ToBools(in ...any) []bool { return conv.ToBools(in...) } // Join - -func (ConvFuncs) Join(in interface{}, sep string) (string, error) { +func (ConvFuncs) Join(in any, sep string) (string, error) { return conv.Join(in, sep) } // ParseInt - -func (ConvFuncs) ParseInt(s interface{}, base, bitSize int) (int64, error) { +func (ConvFuncs) ParseInt(s any, base, bitSize int) (int64, error) { return strconv.ParseInt(conv.ToString(s), base, bitSize) } // ParseFloat - -func (ConvFuncs) ParseFloat(s interface{}, bitSize int) (float64, error) { +func (ConvFuncs) ParseFloat(s any, bitSize int) (float64, error) { return strconv.ParseFloat(conv.ToString(s), bitSize) } // ParseUint - -func (ConvFuncs) ParseUint(s interface{}, base, bitSize int) (uint64, error) { +func (ConvFuncs) ParseUint(s any, base, bitSize int) (uint64, error) { return strconv.ParseUint(conv.ToString(s), base, bitSize) } // Atoi - -func (ConvFuncs) Atoi(s interface{}) (int, error) { +func (ConvFuncs) Atoi(s any) (int, error) { return strconv.Atoi(conv.ToString(s)) } // URL - -func (ConvFuncs) URL(s interface{}) (*url.URL, error) { +func (ConvFuncs) URL(s any) (*url.URL, error) { return url.Parse(conv.ToString(s)) } // ToInt64 - -func (ConvFuncs) ToInt64(in interface{}) (int64, error) { +func (ConvFuncs) ToInt64(in any) (int64, error) { return conv.ToInt64(in) } // ToInt - -func (ConvFuncs) ToInt(in interface{}) (int, error) { +func (ConvFuncs) ToInt(in any) (int, error) { return conv.ToInt(in) } // ToInt64s - -func (ConvFuncs) ToInt64s(in ...interface{}) ([]int64, error) { +func (ConvFuncs) ToInt64s(in ...any) ([]int64, error) { return conv.ToInt64s(in...) } // ToInts - -func (ConvFuncs) ToInts(in ...interface{}) ([]int, error) { +func (ConvFuncs) ToInts(in ...any) ([]int, error) { return conv.ToInts(in...) } // ToFloat64 - -func (ConvFuncs) ToFloat64(in interface{}) (float64, error) { +func (ConvFuncs) ToFloat64(in any) (float64, error) { return conv.ToFloat64(in) } // ToFloat64s - -func (ConvFuncs) ToFloat64s(in ...interface{}) ([]float64, error) { +func (ConvFuncs) ToFloat64s(in ...any) ([]float64, error) { return conv.ToFloat64s(in...) } // ToString - -func (ConvFuncs) ToString(in interface{}) string { +func (ConvFuncs) ToString(in any) string { return conv.ToString(in) } // ToStrings - -func (ConvFuncs) ToStrings(in ...interface{}) []string { +func (ConvFuncs) ToStrings(in ...any) []string { return conv.ToStrings(in...) } // Default - -func (ConvFuncs) Default(def, in interface{}) interface{} { +func (ConvFuncs) Default(def, in any) any { if truth, ok := template.IsTrue(in); truth && ok { return in } diff --git a/internal/funcs/conv_test.go b/internal/funcs/conv_test.go index 51bbba8b..2fd23eaa 100644 --- a/internal/funcs/conv_test.go +++ b/internal/funcs/conv_test.go @@ -12,14 +12,14 @@ import ( func TestCreateConvFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateConvFuncs(ctx) - actual := fmap["conv"].(func() interface{}) + actual := fmap["conv"].(func() any) assert.Equal(t, ctx, actual().(*ConvFuncs).ctx) }) @@ -33,7 +33,7 @@ func TestDefault(t *testing.T) { c := &ConvFuncs{} def := "DEFAULT" data := []struct { - val interface{} + val any empty bool }{ {0, true}, diff --git a/internal/funcs/crypto.go b/internal/funcs/crypto.go index 8807d518..63387c1c 100644 --- a/internal/funcs/crypto.go +++ b/internal/funcs/crypto.go @@ -20,12 +20,12 @@ import ( ) // CreateCryptoFuncs - -func CreateCryptoFuncs(ctx context.Context) map[string]interface{} { - f := map[string]interface{}{} +func CreateCryptoFuncs(ctx context.Context) map[string]any { + f := map[string]any{} ns := &CryptoFuncs{ctx} - f["crypto"] = func() interface{} { return ns } + f["crypto"] = func() any { return ns } return f } @@ -37,7 +37,7 @@ type CryptoFuncs struct { // PBKDF2 - Run the Password-Based Key Derivation Function #2 as defined in // RFC 2898 (PKCS #5 v2.0). This function outputs the binary result in hex // format. -func (CryptoFuncs) PBKDF2(password, salt, iter, keylen interface{}, hashFunc ...string) (k string, err error) { +func (CryptoFuncs) PBKDF2(password, salt, iter, keylen any, hashFunc ...string) (k string, err error) { var h gcrypto.Hash if len(hashFunc) == 0 { h = gcrypto.SHA1 @@ -65,36 +65,36 @@ func (CryptoFuncs) PBKDF2(password, salt, iter, keylen interface{}, hashFunc ... } // WPAPSK - Convert an ASCII passphrase to WPA PSK for a given SSID -func (f CryptoFuncs) WPAPSK(ssid, password interface{}) (string, error) { +func (f CryptoFuncs) WPAPSK(ssid, password any) (string, error) { return f.PBKDF2(password, ssid, 4096, 32) } // SHA1 - Note: SHA-1 is cryptographically broken and should not be used for secure applications. -func (f CryptoFuncs) SHA1(input interface{}) string { +func (f CryptoFuncs) SHA1(input any) string { out, _ := f.SHA1Bytes(input) return fmt.Sprintf("%02x", out) } // SHA224 - -func (f CryptoFuncs) SHA224(input interface{}) string { +func (f CryptoFuncs) SHA224(input any) string { out, _ := f.SHA224Bytes(input) return fmt.Sprintf("%02x", out) } // SHA256 - -func (f CryptoFuncs) SHA256(input interface{}) string { +func (f CryptoFuncs) SHA256(input any) string { out, _ := f.SHA256Bytes(input) return fmt.Sprintf("%02x", out) } // SHA384 - -func (f CryptoFuncs) SHA384(input interface{}) string { +func (f CryptoFuncs) SHA384(input any) string { out, _ := f.SHA384Bytes(input) return fmt.Sprintf("%02x", out) } // SHA512 - -func (f CryptoFuncs) SHA512(input interface{}) string { +func (f CryptoFuncs) SHA512(input any) string { out, _ := f.SHA512Bytes(input) return fmt.Sprintf("%02x", out) } @@ -102,7 +102,7 @@ func (f CryptoFuncs) SHA512(input interface{}) string { // SHA512_224 - // //nolint:revive,stylecheck -func (f CryptoFuncs) SHA512_224(input interface{}) string { +func (f CryptoFuncs) SHA512_224(input any) string { out, _ := f.SHA512_224Bytes(input) return fmt.Sprintf("%02x", out) } @@ -110,13 +110,13 @@ func (f CryptoFuncs) SHA512_224(input interface{}) string { // SHA512_256 - // //nolint:revive,stylecheck -func (f CryptoFuncs) SHA512_256(input interface{}) string { +func (f CryptoFuncs) SHA512_256(input any) string { out, _ := f.SHA512_256Bytes(input) return fmt.Sprintf("%02x", out) } // SHA1 - Note: SHA-1 is cryptographically broken and should not be used for secure applications. -func (CryptoFuncs) SHA1Bytes(input interface{}) ([]byte, error) { +func (CryptoFuncs) SHA1Bytes(input any) ([]byte, error) { //nolint:gosec b := sha1.Sum(toBytes(input)) out := make([]byte, len(b)) @@ -125,7 +125,7 @@ func (CryptoFuncs) SHA1Bytes(input interface{}) ([]byte, error) { } // SHA224 - -func (CryptoFuncs) SHA224Bytes(input interface{}) ([]byte, error) { +func (CryptoFuncs) SHA224Bytes(input any) ([]byte, error) { b := sha256.Sum224(toBytes(input)) out := make([]byte, len(b)) copy(out, b[:]) @@ -133,7 +133,7 @@ func (CryptoFuncs) SHA224Bytes(input interface{}) ([]byte, error) { } // SHA256 - -func (CryptoFuncs) SHA256Bytes(input interface{}) ([]byte, error) { +func (CryptoFuncs) SHA256Bytes(input any) ([]byte, error) { b := sha256.Sum256(toBytes(input)) out := make([]byte, len(b)) copy(out, b[:]) @@ -141,7 +141,7 @@ func (CryptoFuncs) SHA256Bytes(input interface{}) ([]byte, error) { } // SHA384 - -func (CryptoFuncs) SHA384Bytes(input interface{}) ([]byte, error) { +func (CryptoFuncs) SHA384Bytes(input any) ([]byte, error) { b := sha512.Sum384(toBytes(input)) out := make([]byte, len(b)) copy(out, b[:]) @@ -149,7 +149,7 @@ func (CryptoFuncs) SHA384Bytes(input interface{}) ([]byte, error) { } // SHA512 - -func (CryptoFuncs) SHA512Bytes(input interface{}) ([]byte, error) { +func (CryptoFuncs) SHA512Bytes(input any) ([]byte, error) { b := sha512.Sum512(toBytes(input)) out := make([]byte, len(b)) copy(out, b[:]) @@ -157,7 +157,7 @@ func (CryptoFuncs) SHA512Bytes(input interface{}) ([]byte, error) { } // SHA512_224 - -func (CryptoFuncs) SHA512_224Bytes(input interface{}) ([]byte, error) { +func (CryptoFuncs) SHA512_224Bytes(input any) ([]byte, error) { b := sha512.Sum512_224(toBytes(input)) out := make([]byte, len(b)) copy(out, b[:]) @@ -165,7 +165,7 @@ func (CryptoFuncs) SHA512_224Bytes(input interface{}) ([]byte, error) { } // SHA512_256 - -func (CryptoFuncs) SHA512_256Bytes(input interface{}) ([]byte, error) { +func (CryptoFuncs) SHA512_256Bytes(input any) ([]byte, error) { b := sha512.Sum512_256(toBytes(input)) out := make([]byte, len(b)) copy(out, b[:]) @@ -173,7 +173,7 @@ func (CryptoFuncs) SHA512_256Bytes(input interface{}) ([]byte, error) { } // Bcrypt - -func (CryptoFuncs) Bcrypt(args ...interface{}) (string, error) { +func (CryptoFuncs) Bcrypt(args ...any) (string, error) { input := "" var err error @@ -199,7 +199,7 @@ func (CryptoFuncs) Bcrypt(args ...interface{}) (string, error) { // RSAEncrypt - // Experimental! -func (f *CryptoFuncs) RSAEncrypt(key string, in interface{}) ([]byte, error) { +func (f *CryptoFuncs) RSAEncrypt(key string, in any) ([]byte, error) { if err := checkExperimental(f.ctx); err != nil { return nil, err } @@ -229,7 +229,7 @@ func (f *CryptoFuncs) RSADecryptBytes(key string, in []byte) ([]byte, error) { // RSAGenerateKey - // Experimental! -func (f *CryptoFuncs) RSAGenerateKey(args ...interface{}) (string, error) { +func (f *CryptoFuncs) RSAGenerateKey(args ...any) (string, error) { err := checkExperimental(f.ctx) if err != nil { return "", err @@ -261,7 +261,7 @@ func (f *CryptoFuncs) RSADerivePublicKey(privateKey string) (string, error) { // ECDSAGenerateKey - // Experimental! -func (f *CryptoFuncs) ECDSAGenerateKey(args ...interface{}) (string, error) { +func (f *CryptoFuncs) ECDSAGenerateKey(args ...any) (string, error) { if err := checkExperimental(f.ctx); err != nil { return "", err } @@ -343,7 +343,7 @@ func (f *CryptoFuncs) Ed25519DerivePublicKey(privateKey string) (string, error) // EncryptAES - // Experimental! -func (f *CryptoFuncs) EncryptAES(key string, args ...interface{}) ([]byte, error) { +func (f *CryptoFuncs) EncryptAES(key string, args ...any) ([]byte, error) { if err := checkExperimental(f.ctx); err != nil { return nil, err } @@ -358,7 +358,7 @@ func (f *CryptoFuncs) EncryptAES(key string, args ...interface{}) ([]byte, error // DecryptAES - // Experimental! -func (f *CryptoFuncs) DecryptAES(key string, args ...interface{}) (string, error) { +func (f *CryptoFuncs) DecryptAES(key string, args ...any) (string, error) { if err := checkExperimental(f.ctx); err != nil { return "", err } @@ -369,7 +369,7 @@ func (f *CryptoFuncs) DecryptAES(key string, args ...interface{}) (string, error // DecryptAESBytes - // Experimental! -func (f *CryptoFuncs) DecryptAESBytes(key string, args ...interface{}) ([]byte, error) { +func (f *CryptoFuncs) DecryptAESBytes(key string, args ...any) ([]byte, error) { if err := checkExperimental(f.ctx); err != nil { return nil, err } @@ -382,7 +382,7 @@ func (f *CryptoFuncs) DecryptAESBytes(key string, args ...interface{}) ([]byte, return crypto.DecryptAESCBC(k, msg) } -func parseAESArgs(key string, args ...interface{}) ([]byte, []byte, error) { +func parseAESArgs(key string, args ...any) ([]byte, []byte, error) { keyBits := 256 // default to AES-256-CBC var msg []byte diff --git a/internal/funcs/crypto_test.go b/internal/funcs/crypto_test.go index e2b15415..75e7c6df 100644 --- a/internal/funcs/crypto_test.go +++ b/internal/funcs/crypto_test.go @@ -13,14 +13,14 @@ import ( ) func TestCreateCryptoFuncs(t *testing.T) { - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateCryptoFuncs(ctx) - actual := fmap["crypto"].(func() interface{}) + actual := fmap["crypto"].(func() any) assert.Equal(t, ctx, actual().(*CryptoFuncs).ctx) }) diff --git a/internal/funcs/data.go b/internal/funcs/data.go index 085dbc54..1666f689 100644 --- a/internal/funcs/data.go +++ b/internal/funcs/data.go @@ -8,12 +8,12 @@ import ( ) // CreateDataFuncs - -func CreateDataFuncs(ctx context.Context) map[string]interface{} { - f := map[string]interface{}{} +func CreateDataFuncs(ctx context.Context) map[string]any { + f := map[string]any{} ns := &DataFuncs{ctx} - f["data"] = func() interface{} { return ns } + f["data"] = func() any { return ns } f["json"] = ns.JSON f["jsonArray"] = ns.JSONArray @@ -39,27 +39,27 @@ type DataFuncs struct { } // JSON - -func (f *DataFuncs) JSON(in interface{}) (map[string]interface{}, error) { +func (f *DataFuncs) JSON(in any) (map[string]any, error) { return parsers.JSON(conv.ToString(in)) } // JSONArray - -func (f *DataFuncs) JSONArray(in interface{}) ([]interface{}, error) { +func (f *DataFuncs) JSONArray(in any) ([]any, error) { return parsers.JSONArray(conv.ToString(in)) } // YAML - -func (f *DataFuncs) YAML(in interface{}) (map[string]interface{}, error) { +func (f *DataFuncs) YAML(in any) (map[string]any, error) { return parsers.YAML(conv.ToString(in)) } // YAMLArray - -func (f *DataFuncs) YAMLArray(in interface{}) ([]interface{}, error) { +func (f *DataFuncs) YAMLArray(in any) ([]any, error) { return parsers.YAMLArray(conv.ToString(in)) } // TOML - -func (f *DataFuncs) TOML(in interface{}) (interface{}, error) { +func (f *DataFuncs) TOML(in any) (any, error) { return parsers.TOML(conv.ToString(in)) } @@ -79,36 +79,36 @@ func (f *DataFuncs) CSVByColumn(args ...string) (cols map[string][]string, err e } // CUE - -func (f *DataFuncs) CUE(in interface{}) (interface{}, error) { +func (f *DataFuncs) CUE(in any) (any, error) { return parsers.CUE(conv.ToString(in)) } // ToCSV - -func (f *DataFuncs) ToCSV(args ...interface{}) (string, error) { +func (f *DataFuncs) ToCSV(args ...any) (string, error) { return parsers.ToCSV(args...) } // ToCUE - -func (f *DataFuncs) ToCUE(in interface{}) (string, error) { +func (f *DataFuncs) ToCUE(in any) (string, error) { return parsers.ToCUE(in) } // ToJSON - -func (f *DataFuncs) ToJSON(in interface{}) (string, error) { +func (f *DataFuncs) ToJSON(in any) (string, error) { return parsers.ToJSON(in) } // ToJSONPretty - -func (f *DataFuncs) ToJSONPretty(indent string, in interface{}) (string, error) { +func (f *DataFuncs) ToJSONPretty(indent string, in any) (string, error) { return parsers.ToJSONPretty(indent, in) } // ToYAML - -func (f *DataFuncs) ToYAML(in interface{}) (string, error) { +func (f *DataFuncs) ToYAML(in any) (string, error) { return parsers.ToYAML(in) } // ToTOML - -func (f *DataFuncs) ToTOML(in interface{}) (string, error) { +func (f *DataFuncs) ToTOML(in any) (string, error) { return parsers.ToTOML(in) } diff --git a/internal/funcs/data_test.go b/internal/funcs/data_test.go index b01530b6..d7dccedf 100644 --- a/internal/funcs/data_test.go +++ b/internal/funcs/data_test.go @@ -11,14 +11,14 @@ import ( func TestCreateDataFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateDataFuncs(ctx) - actual := fmap["data"].(func() interface{}) + actual := fmap["data"].(func() any) assert.Equal(t, ctx, actual().(*DataFuncs).ctx) }) diff --git a/internal/funcs/datasource.go b/internal/funcs/datasource.go index 6c4badf8..e1232231 100644 --- a/internal/funcs/datasource.go +++ b/internal/funcs/datasource.go @@ -12,16 +12,16 @@ import ( ) // CreateDataSourceFuncs - -func CreateDataSourceFuncs(ctx context.Context, sr datafs.DataSourceReader) map[string]interface{} { +func CreateDataSourceFuncs(ctx context.Context, sr datafs.DataSourceReader) map[string]any { ns := &dataSourceFuncs{ ctx: ctx, sr: sr, } - f := map[string]interface{}{} + f := map[string]any{} // undocumented but available - f["_datasource"] = func() interface{} { return ns } + f["_datasource"] = func() any { return ns } f["datasource"] = ns.Datasource f["ds"] = ns.Datasource @@ -52,7 +52,7 @@ func (d *dataSourceFuncs) Include(alias string, args ...string) (string, error) } // Datasource - Reads from the named datasource, and returns the parsed datafs. -func (d *dataSourceFuncs) Datasource(alias string, args ...string) (interface{}, error) { +func (d *dataSourceFuncs) Datasource(alias string, args ...string) (any, error) { ct, b, err := d.sr.ReadSource(d.ctx, alias, args...) if err != nil { return nil, err diff --git a/internal/funcs/datasource_test.go b/internal/funcs/datasource_test.go index 3c5f5f7f..18050009 100644 --- a/internal/funcs/datasource_test.go +++ b/internal/funcs/datasource_test.go @@ -19,14 +19,14 @@ import ( func TestCreateDataSourceFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateDataSourceFuncs(ctx, nil) - actual := fmap["_datasource"].(func() interface{}) + actual := fmap["_datasource"].(func() any) assert.Equal(t, ctx, actual().(*dataSourceFuncs).ctx) }) @@ -57,7 +57,7 @@ func TestDatasource(t *testing.T) { return d } - test := func(ext, mime string, contents []byte, expected interface{}) { + test := func(ext, mime string, contents []byte, expected any) { data := setup(ext, contents) actual, err := data.Datasource("foo", "?type="+mime) @@ -67,17 +67,17 @@ func TestDatasource(t *testing.T) { testObj := func(ext, mime string, contents []byte) { test(ext, mime, contents, - map[string]interface{}{ - "hello": map[string]interface{}{"cruel": "world"}, + map[string]any{ + "hello": map[string]any{"cruel": "world"}, }) } testObj("json", iohelpers.JSONMimetype, []byte(`{"hello":{"cruel":"world"}}`)) testObj("yml", iohelpers.YAMLMimetype, []byte("hello:\n cruel: world\n")) test("json", iohelpers.JSONMimetype, []byte(`[1, "two", true]`), - []interface{}{1, "two", true}) + []any{1, "two", true}) test("yaml", iohelpers.YAMLMimetype, []byte("---\n- 1\n- two\n- true\n"), - []interface{}{1, "two", true}) + []any{1, "two", true}) d := setup("", nil) actual, err := d.Datasource("foo") diff --git a/internal/funcs/env.go b/internal/funcs/env.go index 61ed9be4..5ec5a17a 100644 --- a/internal/funcs/env.go +++ b/internal/funcs/env.go @@ -8,11 +8,11 @@ import ( ) // CreateEnvFuncs - -func CreateEnvFuncs(ctx context.Context) map[string]interface{} { +func CreateEnvFuncs(ctx context.Context) map[string]any { ns := &EnvFuncs{ctx} - return map[string]interface{}{ - "env": func() interface{} { return ns }, + return map[string]any{ + "env": func() any { return ns }, "getenv": ns.Getenv, } } @@ -23,11 +23,11 @@ type EnvFuncs struct { } // Getenv - -func (EnvFuncs) Getenv(key interface{}, def ...string) string { +func (EnvFuncs) Getenv(key any, def ...string) string { return env.Getenv(conv.ToString(key), def...) } // ExpandEnv - -func (EnvFuncs) ExpandEnv(s interface{}) string { +func (EnvFuncs) ExpandEnv(s any) string { return env.ExpandEnv(conv.ToString(s)) } diff --git a/internal/funcs/env_test.go b/internal/funcs/env_test.go index a6ee43ac..b34d9769 100644 --- a/internal/funcs/env_test.go +++ b/internal/funcs/env_test.go @@ -12,14 +12,14 @@ import ( func TestCreateEnvFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateEnvFuncs(ctx) - actual := fmap["env"].(func() interface{}) + actual := fmap["env"].(func() any) assert.Equal(t, ctx, actual().(*EnvFuncs).ctx) }) diff --git a/internal/funcs/file.go b/internal/funcs/file.go index 16012cf1..508cf6ce 100644 --- a/internal/funcs/file.go +++ b/internal/funcs/file.go @@ -12,7 +12,7 @@ import ( ) // CreateFileFuncs - -func CreateFileFuncs(ctx context.Context) map[string]interface{} { +func CreateFileFuncs(ctx context.Context) map[string]any { fsys, err := datafs.FSysForPath(ctx, "/") if err != nil { fsys = datafs.WrapWdFS(osfs.NewFS()) @@ -23,8 +23,8 @@ func CreateFileFuncs(ctx context.Context) map[string]interface{} { fs: fsys, } - return map[string]interface{}{ - "file": func() interface{} { return ns }, + return map[string]any{ + "file": func() any { return ns }, } } @@ -35,30 +35,30 @@ type FileFuncs struct { } // Read - -func (f *FileFuncs) Read(path interface{}) (string, error) { +func (f *FileFuncs) Read(path any) (string, error) { b, err := fs.ReadFile(f.fs, conv.ToString(path)) return string(b), err } // Stat - -func (f *FileFuncs) Stat(path interface{}) (fs.FileInfo, error) { +func (f *FileFuncs) Stat(path any) (fs.FileInfo, error) { return fs.Stat(f.fs, conv.ToString(path)) } // Exists - -func (f *FileFuncs) Exists(path interface{}) bool { +func (f *FileFuncs) Exists(path any) bool { _, err := f.Stat(conv.ToString(path)) return err == nil } // IsDir - -func (f *FileFuncs) IsDir(path interface{}) bool { +func (f *FileFuncs) IsDir(path any) bool { i, err := f.Stat(conv.ToString(path)) return err == nil && i.IsDir() } // ReadDir - -func (f *FileFuncs) ReadDir(path interface{}) ([]string, error) { +func (f *FileFuncs) ReadDir(path any) ([]string, error) { des, err := fs.ReadDir(f.fs, conv.ToString(path)) if err != nil { return nil, err @@ -73,7 +73,7 @@ func (f *FileFuncs) ReadDir(path interface{}) ([]string, error) { } // Walk - -func (f *FileFuncs) Walk(path interface{}) ([]string, error) { +func (f *FileFuncs) Walk(path any) ([]string, error) { files := make([]string, 0) err := fs.WalkDir(f.fs, conv.ToString(path), func(subpath string, _ fs.DirEntry, err error) error { if err != nil { @@ -92,7 +92,7 @@ func (f *FileFuncs) Walk(path interface{}) ([]string, error) { } // Write - -func (f *FileFuncs) Write(path interface{}, data interface{}) (s string, err error) { +func (f *FileFuncs) Write(path any, data any) (s string, err error) { type byteser interface{ Bytes() []byte } var content []byte diff --git a/internal/funcs/file_test.go b/internal/funcs/file_test.go index 0c2babda..e64836ba 100644 --- a/internal/funcs/file_test.go +++ b/internal/funcs/file_test.go @@ -21,14 +21,14 @@ import ( func TestCreateFileFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateFileFuncs(ctx) - actual := fmap["file"].(func() interface{}) + actual := fmap["file"].(func() any) assert.Equal(t, ctx, actual().(*FileFuncs).ctx) }) diff --git a/internal/funcs/filepath.go b/internal/funcs/filepath.go index ffbd5699..5594a0fa 100644 --- a/internal/funcs/filepath.go +++ b/internal/funcs/filepath.go @@ -8,11 +8,11 @@ import ( ) // CreateFilePathFuncs - -func CreateFilePathFuncs(ctx context.Context) map[string]interface{} { +func CreateFilePathFuncs(ctx context.Context) map[string]any { ns := &FilePathFuncs{ctx} - return map[string]interface{}{ - "filepath": func() interface{} { return ns }, + return map[string]any{ + "filepath": func() any { return ns }, } } @@ -22,63 +22,63 @@ type FilePathFuncs struct { } // Base - -func (f *FilePathFuncs) Base(in interface{}) string { +func (f *FilePathFuncs) Base(in any) string { return filepath.Base(conv.ToString(in)) } // Clean - -func (f *FilePathFuncs) Clean(in interface{}) string { +func (f *FilePathFuncs) Clean(in any) string { return filepath.Clean(conv.ToString(in)) } // Dir - -func (f *FilePathFuncs) Dir(in interface{}) string { +func (f *FilePathFuncs) Dir(in any) string { return filepath.Dir(conv.ToString(in)) } // Ext - -func (f *FilePathFuncs) Ext(in interface{}) string { +func (f *FilePathFuncs) Ext(in any) string { return filepath.Ext(conv.ToString(in)) } // FromSlash - -func (f *FilePathFuncs) FromSlash(in interface{}) string { +func (f *FilePathFuncs) FromSlash(in any) string { return filepath.FromSlash(conv.ToString(in)) } // IsAbs - -func (f *FilePathFuncs) IsAbs(in interface{}) bool { +func (f *FilePathFuncs) IsAbs(in any) bool { return filepath.IsAbs(conv.ToString(in)) } // Join - -func (f *FilePathFuncs) Join(elem ...interface{}) string { +func (f *FilePathFuncs) Join(elem ...any) string { s := conv.ToStrings(elem...) return filepath.Join(s...) } // Match - -func (f *FilePathFuncs) Match(pattern, name interface{}) (matched bool, err error) { +func (f *FilePathFuncs) Match(pattern, name any) (matched bool, err error) { return filepath.Match(conv.ToString(pattern), conv.ToString(name)) } // Rel - -func (f *FilePathFuncs) Rel(basepath, targpath interface{}) (string, error) { +func (f *FilePathFuncs) Rel(basepath, targpath any) (string, error) { return filepath.Rel(conv.ToString(basepath), conv.ToString(targpath)) } // Split - -func (f *FilePathFuncs) Split(in interface{}) []string { +func (f *FilePathFuncs) Split(in any) []string { dir, file := filepath.Split(conv.ToString(in)) return []string{dir, file} } // ToSlash - -func (f *FilePathFuncs) ToSlash(in interface{}) string { +func (f *FilePathFuncs) ToSlash(in any) string { return filepath.ToSlash(conv.ToString(in)) } // VolumeName - -func (f *FilePathFuncs) VolumeName(in interface{}) string { +func (f *FilePathFuncs) VolumeName(in any) string { return filepath.VolumeName(conv.ToString(in)) } diff --git a/internal/funcs/filepath_test.go b/internal/funcs/filepath_test.go index 0c4bbe80..2662c2c6 100644 --- a/internal/funcs/filepath_test.go +++ b/internal/funcs/filepath_test.go @@ -11,14 +11,14 @@ import ( func TestCreateFilePathFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateFilePathFuncs(ctx) - actual := fmap["filepath"].(func() interface{}) + actual := fmap["filepath"].(func() any) assert.Equal(t, ctx, actual().(*FilePathFuncs).ctx) }) diff --git a/internal/funcs/gcp.go b/internal/funcs/gcp.go index b87bd54b..d4278296 100644 --- a/internal/funcs/gcp.go +++ b/internal/funcs/gcp.go @@ -8,13 +8,13 @@ import ( ) // CreateGCPFuncs - -func CreateGCPFuncs(ctx context.Context) map[string]interface{} { +func CreateGCPFuncs(ctx context.Context) map[string]any { ns := &GcpFuncs{ ctx: ctx, gcpopts: gcp.GetClientOptions(), } - return map[string]interface{}{ - "gcp": func() interface{} { return ns }, + return map[string]any{ + "gcp": func() any { return ns }, } } @@ -28,7 +28,7 @@ type GcpFuncs struct { // Meta - func (a *GcpFuncs) Meta(key string, def ...string) (string, error) { - a.meta = sync.OnceValue[*gcp.MetaClient](func() *gcp.MetaClient { + a.meta = sync.OnceValue(func() *gcp.MetaClient { return gcp.NewMetaClient(a.ctx, a.gcpopts) })() diff --git a/internal/funcs/gcp_test.go b/internal/funcs/gcp_test.go index 91ab54fb..ce9fff42 100644 --- a/internal/funcs/gcp_test.go +++ b/internal/funcs/gcp_test.go @@ -11,14 +11,14 @@ import ( func TestCreateGCPFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateGCPFuncs(ctx) - actual := fmap["gcp"].(func() interface{}) + actual := fmap["gcp"].(func() any) assert.Equal(t, ctx, actual().(*GcpFuncs).ctx) }) diff --git a/internal/funcs/math.go b/internal/funcs/math.go index 694586a7..fbdbab5b 100644 --- a/internal/funcs/math.go +++ b/internal/funcs/math.go @@ -4,6 +4,7 @@ import ( "context" "fmt" gmath "math" + "slices" "strconv" "github.com/hairyhenderson/gomplate/v4/conv" @@ -12,11 +13,11 @@ import ( ) // CreateMathFuncs - -func CreateMathFuncs(ctx context.Context) map[string]interface{} { - f := map[string]interface{}{} +func CreateMathFuncs(ctx context.Context) map[string]any { + f := map[string]any{} ns := &MathFuncs{ctx} - f["math"] = func() interface{} { return ns } + f["math"] = func() any { return ns } f["add"] = ns.Add f["sub"] = ns.Sub @@ -34,7 +35,7 @@ type MathFuncs struct { } // IsInt - -func (f MathFuncs) IsInt(n interface{}) bool { +func (f MathFuncs) IsInt(n any) bool { switch i := n.(type) { case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64: return true @@ -46,7 +47,7 @@ func (f MathFuncs) IsInt(n interface{}) bool { } // IsFloat - -func (f MathFuncs) IsFloat(n interface{}) bool { +func (f MathFuncs) IsFloat(n any) bool { switch i := n.(type) { case float32, float64: return true @@ -63,23 +64,13 @@ func (f MathFuncs) IsFloat(n interface{}) bool { return false } -func (f MathFuncs) containsFloat(n ...interface{}) bool { - c := false - for _, v := range n { - if f.IsFloat(v) { - return true - } - } - return c -} - // IsNum - -func (f MathFuncs) IsNum(n interface{}) bool { +func (f MathFuncs) IsNum(n any) bool { return f.IsInt(n) || f.IsFloat(n) } // Abs - -func (f MathFuncs) Abs(n interface{}) (interface{}, error) { +func (f MathFuncs) Abs(n any) (any, error) { fn, err := conv.ToFloat64(n) if err != nil { return nil, fmt.Errorf("expected a number: %w", err) @@ -94,8 +85,8 @@ func (f MathFuncs) Abs(n interface{}) (interface{}, error) { } // Add - -func (f MathFuncs) Add(n ...interface{}) (interface{}, error) { - if f.containsFloat(n...) { +func (f MathFuncs) Add(n ...any) (any, error) { + if slices.ContainsFunc(n, f.IsFloat) { nums, err := conv.ToFloat64s(n...) if err != nil { return nil, fmt.Errorf("expected number inputs: %w", err) @@ -123,8 +114,8 @@ func (f MathFuncs) Add(n ...interface{}) (interface{}, error) { } // Mul - -func (f MathFuncs) Mul(n ...interface{}) (interface{}, error) { - if f.containsFloat(n...) { +func (f MathFuncs) Mul(n ...any) (any, error) { + if slices.ContainsFunc(n, f.IsFloat) { nums, err := conv.ToFloat64s(n...) if err != nil { return nil, fmt.Errorf("expected number inputs: %w", err) @@ -152,8 +143,8 @@ func (f MathFuncs) Mul(n ...interface{}) (interface{}, error) { } // Sub - -func (f MathFuncs) Sub(a, b interface{}) (interface{}, error) { - if f.containsFloat(a, b) { +func (f MathFuncs) Sub(a, b any) (any, error) { + if slices.ContainsFunc([]any{a, b}, f.IsFloat) { fa, err := conv.ToFloat64(a) if err != nil { return nil, fmt.Errorf("expected a number: %w", err) @@ -181,7 +172,7 @@ func (f MathFuncs) Sub(a, b interface{}) (interface{}, error) { } // Div - -func (f MathFuncs) Div(a, b interface{}) (interface{}, error) { +func (f MathFuncs) Div(a, b any) (any, error) { divisor, err := conv.ToFloat64(a) if err != nil { return nil, fmt.Errorf("expected a number: %w", err) @@ -200,7 +191,7 @@ func (f MathFuncs) Div(a, b interface{}) (interface{}, error) { } // Rem - -func (f MathFuncs) Rem(a, b interface{}) (interface{}, error) { +func (f MathFuncs) Rem(a, b any) (any, error) { ia, err := conv.ToInt64(a) if err != nil { return nil, fmt.Errorf("expected a number: %w", err) @@ -215,7 +206,7 @@ func (f MathFuncs) Rem(a, b interface{}) (interface{}, error) { } // Pow - -func (f MathFuncs) Pow(a, b interface{}) (interface{}, error) { +func (f MathFuncs) Pow(a, b any) (any, error) { fa, err := conv.ToFloat64(a) if err != nil { return nil, fmt.Errorf("expected a number: %w", err) @@ -236,7 +227,7 @@ func (f MathFuncs) Pow(a, b interface{}) (interface{}, error) { // Seq - return a sequence from `start` to `end`, in steps of `step` // start and step are optional, and default to 1. -func (f MathFuncs) Seq(n ...interface{}) ([]int64, error) { +func (f MathFuncs) Seq(n ...any) ([]int64, error) { start := int64(1) end := int64(0) step := int64(1) @@ -282,8 +273,8 @@ func (f MathFuncs) Seq(n ...interface{}) ([]int64, error) { } // Max - -func (f MathFuncs) Max(a interface{}, b ...interface{}) (interface{}, error) { - if f.IsFloat(a) || f.containsFloat(b...) { +func (f MathFuncs) Max(a any, b ...any) (any, error) { + if f.IsFloat(a) || slices.ContainsFunc(b, f.IsFloat) { m, err := conv.ToFloat64(a) if err != nil { return nil, fmt.Errorf("expected a number: %w", err) @@ -321,8 +312,8 @@ func (f MathFuncs) Max(a interface{}, b ...interface{}) (interface{}, error) { } // Min - -func (f MathFuncs) Min(a interface{}, b ...interface{}) (interface{}, error) { - if f.IsFloat(a) || f.containsFloat(b...) { +func (f MathFuncs) Min(a any, b ...any) (any, error) { + if f.IsFloat(a) || slices.ContainsFunc(b, f.IsFloat) { m, err := conv.ToFloat64(a) if err != nil { return nil, fmt.Errorf("expected a number: %w", err) @@ -358,7 +349,7 @@ func (f MathFuncs) Min(a interface{}, b ...interface{}) (interface{}, error) { } // Ceil - -func (f MathFuncs) Ceil(n interface{}) (interface{}, error) { +func (f MathFuncs) Ceil(n any) (any, error) { in, err := conv.ToFloat64(n) if err != nil { return nil, fmt.Errorf("n must be a number: %w", err) @@ -368,7 +359,7 @@ func (f MathFuncs) Ceil(n interface{}) (interface{}, error) { } // Floor - -func (f MathFuncs) Floor(n interface{}) (interface{}, error) { +func (f MathFuncs) Floor(n any) (any, error) { in, err := conv.ToFloat64(n) if err != nil { return nil, fmt.Errorf("n must be a number: %w", err) @@ -378,7 +369,7 @@ func (f MathFuncs) Floor(n interface{}) (interface{}, error) { } // Round - -func (f MathFuncs) Round(n interface{}) (interface{}, error) { +func (f MathFuncs) Round(n any) (any, error) { in, err := conv.ToFloat64(n) if err != nil { return nil, fmt.Errorf("n must be a number: %w", err) diff --git a/internal/funcs/math_test.go b/internal/funcs/math_test.go index d55f973a..717db2b6 100644 --- a/internal/funcs/math_test.go +++ b/internal/funcs/math_test.go @@ -4,6 +4,7 @@ import ( "context" "fmt" gmath "math" + "slices" "strconv" "testing" @@ -14,14 +15,14 @@ import ( func TestCreateMathFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateMathFuncs(ctx) - actual := fmap["math"].(func() interface{}) + actual := fmap["math"].(func() any) assert.Equal(t, ctx, actual().(*MathFuncs).ctx) }) @@ -106,7 +107,7 @@ func TestSub(t *testing.T) { assert.InEpsilon(t, -5.3, actual, 1e-12) } -func mustDiv(a, b interface{}) interface{} { +func mustDiv(a, b any) any { m := MathFuncs{} r, err := m.Div(a, b) if err != nil { @@ -155,7 +156,7 @@ func TestPow(t *testing.T) { assert.InEpsilon(t, 2.25, actual, 1e-12) } -func mustSeq(t *testing.T, n ...interface{}) []int64 { +func mustSeq(t *testing.T, n ...any) []int64 { m := MathFuncs{} s, err := m.Seq(n...) if err != nil { @@ -181,7 +182,7 @@ func TestIsIntFloatNum(t *testing.T) { t.Parallel() tests := []struct { - in interface{} + in any isInt bool isFloat bool }{ @@ -232,14 +233,14 @@ func TestIsIntFloatNum(t *testing.T) { } func BenchmarkIsFloat(b *testing.B) { - data := []interface{}{ + data := []any{ 0, 1, -1, uint(42), uint8(255), uint16(42), uint32(42), uint64(42), int(42), int8(127), int16(42), int32(42), int64(42), float32(18.3), float64(18.3), 1.5, -18.6, "42", "052", "0xff", "-42", "-0", "3.14", "-3.14", "0.00", "NaN", "-Inf", "+Inf", "", "foo", nil, true, } m := MathFuncs{} for _, n := range data { b.Run(fmt.Sprintf("%T(%v)", n, n), func(b *testing.B) { - for i := 0; i < b.N; i++ { + for b.Loop() { m.IsFloat(n) } }) @@ -251,21 +252,21 @@ func TestMax(t *testing.T) { m := MathFuncs{} data := []struct { - expected interface{} - n []interface{} + expected any + n []any }{ - {int64(0), []interface{}{0}}, - {int64(1), []interface{}{1}}, - {int64(-1), []interface{}{-1}}, - {int64(1), []interface{}{-1, 0, 1}}, - {3.9, []interface{}{3.14, 3, 3.9}}, - {int64(255), []interface{}{"14", "0xff", -5}}, + {int64(0), []any{0}}, + {int64(1), []any{1}}, + {int64(-1), []any{-1}}, + {int64(1), []any{-1, 0, 1}}, + {3.9, []any{3.14, 3, 3.9}}, + {int64(255), []any{"14", "0xff", -5}}, } for _, d := range data { t.Run(fmt.Sprintf("%v==%v", d.n, d.expected), func(t *testing.T) { t.Parallel() - var actual interface{} + var actual any if len(d.n) == 1 { actual, _ = m.Max(d.n[0]) } else { @@ -294,21 +295,21 @@ func TestMin(t *testing.T) { m := MathFuncs{} data := []struct { - expected interface{} - n []interface{} + expected any + n []any }{ - {int64(0), []interface{}{0}}, - {int64(1), []interface{}{1}}, - {int64(-1), []interface{}{-1}}, - {int64(-1), []interface{}{-1, 0, 1}}, - {3., []interface{}{3.14, 3, 3.9}}, - {int64(-5), []interface{}{"14", "0xff", -5}}, + {int64(0), []any{0}}, + {int64(1), []any{1}}, + {int64(-1), []any{-1}}, + {int64(-1), []any{-1, 0, 1}}, + {3., []any{3.14, 3, 3.9}}, + {int64(-5), []any{"14", "0xff", -5}}, } for _, d := range data { t.Run(fmt.Sprintf("%v==%v", d.n, d.expected), func(t *testing.T) { t.Parallel() - var actual interface{} + var actual any if len(d.n) == 1 { actual, _ = m.Min(d.n[0]) } else { @@ -338,29 +339,29 @@ func TestContainsFloat(t *testing.T) { m := MathFuncs{} data := []struct { - n []interface{} + n []any expected bool }{ - {[]interface{}{nil}, false}, - {[]interface{}{0}, false}, - {[]interface{}{"not a number"}, false}, - {[]interface{}{1}, false}, - {[]interface{}{-1}, false}, - {[]interface{}{-1, 0, 1}, false}, - {[]interface{}{3.14, 3, 3.9}, true}, - {[]interface{}{"14", "0xff", -5}, false}, - {[]interface{}{"14.8", "0xff", -5}, true}, - {[]interface{}{"-Inf", 2}, true}, - {[]interface{}{"NaN"}, true}, + {[]any{nil}, false}, + {[]any{0}, false}, + {[]any{"not a number"}, false}, + {[]any{1}, false}, + {[]any{-1}, false}, + {[]any{-1, 0, 1}, false}, + {[]any{3.14, 3, 3.9}, true}, + {[]any{"14", "0xff", -5}, false}, + {[]any{"14.8", "0xff", -5}, true}, + {[]any{"-Inf", 2}, true}, + {[]any{"NaN"}, true}, } for _, d := range data { t.Run(fmt.Sprintf("%v==%v", d.n, d.expected), func(t *testing.T) { t.Parallel() if d.expected { - assert.True(t, m.containsFloat(d.n...)) + assert.True(t, slices.ContainsFunc(d.n, m.IsFloat)) } else { - assert.False(t, m.containsFloat(d.n...)) + assert.False(t, slices.ContainsFunc(d.n, m.IsFloat)) } }) } @@ -371,7 +372,7 @@ func TestCeil(t *testing.T) { m := MathFuncs{} data := []struct { - n interface{} + n any a float64 }{ {"Inf", gmath.Inf(1)}, @@ -409,7 +410,7 @@ func TestFloor(t *testing.T) { m := MathFuncs{} data := []struct { - n interface{} + n any a float64 }{ {"Inf", gmath.Inf(1)}, @@ -447,7 +448,7 @@ func TestRound(t *testing.T) { m := MathFuncs{} data := []struct { - n interface{} + n any a float64 }{ {"Inf", gmath.Inf(1)}, @@ -489,8 +490,8 @@ func TestAbs(t *testing.T) { m := MathFuncs{} data := []struct { - n interface{} - a interface{} + n any + a any }{ {"-Inf", gmath.Inf(1)}, {0, int64(0)}, diff --git a/internal/funcs/net.go b/internal/funcs/net.go index e8d8288d..851033f2 100644 --- a/internal/funcs/net.go +++ b/internal/funcs/net.go @@ -16,10 +16,10 @@ import ( ) // CreateNetFuncs - -func CreateNetFuncs(ctx context.Context) map[string]interface{} { +func CreateNetFuncs(ctx context.Context) map[string]any { ns := &NetFuncs{ctx} - return map[string]interface{}{ - "net": func() interface{} { return ns }, + return map[string]any{ + "net": func() any { return ns }, } } @@ -29,39 +29,39 @@ type NetFuncs struct { } // LookupIP - -func (f NetFuncs) LookupIP(name interface{}) (string, error) { +func (f NetFuncs) LookupIP(name any) (string, error) { return net.LookupIP(conv.ToString(name)) } // LookupIPs - -func (f NetFuncs) LookupIPs(name interface{}) ([]string, error) { +func (f NetFuncs) LookupIPs(name any) ([]string, error) { return net.LookupIPs(conv.ToString(name)) } // LookupCNAME - -func (f NetFuncs) LookupCNAME(name interface{}) (string, error) { +func (f NetFuncs) LookupCNAME(name any) (string, error) { return net.LookupCNAME(conv.ToString(name)) } // LookupSRV - -func (f NetFuncs) LookupSRV(name interface{}) (*stdnet.SRV, error) { +func (f NetFuncs) LookupSRV(name any) (*stdnet.SRV, error) { return net.LookupSRV(conv.ToString(name)) } // LookupSRVs - -func (f NetFuncs) LookupSRVs(name interface{}) ([]*stdnet.SRV, error) { +func (f NetFuncs) LookupSRVs(name any) ([]*stdnet.SRV, error) { return net.LookupSRVs(conv.ToString(name)) } // LookupTXT - -func (f NetFuncs) LookupTXT(name interface{}) ([]string, error) { +func (f NetFuncs) LookupTXT(name any) ([]string, error) { return net.LookupTXT(conv.ToString(name)) } // ParseIP - // // Deprecated: use [ParseAddr] instead -func (f *NetFuncs) ParseIP(ip interface{}) (netaddr.IP, error) { +func (f *NetFuncs) ParseIP(ip any) (netaddr.IP, error) { deprecated.WarnDeprecated(f.ctx, "net.ParseIP is deprecated - use net.ParseAddr instead") return netaddr.ParseIP(conv.ToString(ip)) } @@ -69,7 +69,7 @@ func (f *NetFuncs) ParseIP(ip interface{}) (netaddr.IP, error) { // ParseIPPrefix - // // Deprecated: use [ParsePrefix] instead -func (f *NetFuncs) ParseIPPrefix(ipprefix interface{}) (netaddr.IPPrefix, error) { +func (f *NetFuncs) ParseIPPrefix(ipprefix any) (netaddr.IPPrefix, error) { deprecated.WarnDeprecated(f.ctx, "net.ParseIPPrefix is deprecated - use net.ParsePrefix instead") return netaddr.ParseIPPrefix(conv.ToString(ipprefix)) } @@ -77,29 +77,29 @@ func (f *NetFuncs) ParseIPPrefix(ipprefix interface{}) (netaddr.IPPrefix, error) // ParseIPRange - // // Deprecated: use [ParseRange] instead -func (f *NetFuncs) ParseIPRange(iprange interface{}) (netaddr.IPRange, error) { +func (f *NetFuncs) ParseIPRange(iprange any) (netaddr.IPRange, error) { deprecated.WarnDeprecated(f.ctx, "net.ParseIPRange is deprecated - use net.ParseRange instead") return netaddr.ParseIPRange(conv.ToString(iprange)) } // ParseAddr - -func (f NetFuncs) ParseAddr(ip interface{}) (netip.Addr, error) { +func (f NetFuncs) ParseAddr(ip any) (netip.Addr, error) { return netip.ParseAddr(conv.ToString(ip)) } // ParsePrefix - -func (f NetFuncs) ParsePrefix(ipprefix interface{}) (netip.Prefix, error) { +func (f NetFuncs) ParsePrefix(ipprefix any) (netip.Prefix, error) { return netip.ParsePrefix(conv.ToString(ipprefix)) } // ParseRange - // // Experimental: this API may change in the future -func (f NetFuncs) ParseRange(iprange interface{}) (netipx.IPRange, error) { +func (f NetFuncs) ParseRange(iprange any) (netipx.IPRange, error) { return netipx.ParseIPRange(conv.ToString(iprange)) } -func (f *NetFuncs) parseNetipPrefix(prefix interface{}) (netip.Prefix, error) { +func (f *NetFuncs) parseNetipPrefix(prefix any) (netip.Prefix, error) { switch p := prefix.(type) { case *stdnet.IPNet: return f.ipPrefixFromIPNet(p), nil @@ -122,7 +122,7 @@ func (f NetFuncs) ipPrefixFromIPNet(n *stdnet.IPNet) netip.Prefix { // CIDRHost - // Experimental! -func (f *NetFuncs) CIDRHost(hostnum interface{}, prefix interface{}) (netip.Addr, error) { +func (f *NetFuncs) CIDRHost(hostnum any, prefix any) (netip.Addr, error) { if err := checkExperimental(f.ctx); err != nil { return netip.Addr{}, err } @@ -144,7 +144,7 @@ func (f *NetFuncs) CIDRHost(hostnum interface{}, prefix interface{}) (netip.Addr // CIDRNetmask - // Experimental! -func (f *NetFuncs) CIDRNetmask(prefix interface{}) (netip.Addr, error) { +func (f *NetFuncs) CIDRNetmask(prefix any) (netip.Addr, error) { if err := checkExperimental(f.ctx); err != nil { return netip.Addr{}, err } @@ -156,7 +156,7 @@ func (f *NetFuncs) CIDRNetmask(prefix interface{}) (netip.Addr, error) { // fill an appropriately sized byte slice with as many 1s as prefix bits b := make([]byte, p.Addr().BitLen()/8) - for i := 0; i < p.Bits(); i++ { + for i := range p.Bits() { //nolint:gosec // G115 is not applicable, the value was checked at parse // time b[i/8] |= 1 << uint(7-i%8) @@ -172,7 +172,7 @@ func (f *NetFuncs) CIDRNetmask(prefix interface{}) (netip.Addr, error) { // CIDRSubnets - // Experimental! -func (f *NetFuncs) CIDRSubnets(newbits interface{}, prefix interface{}) ([]netip.Prefix, error) { +func (f *NetFuncs) CIDRSubnets(newbits any, prefix any) ([]netip.Prefix, error) { if err := checkExperimental(f.ctx); err != nil { return nil, err } @@ -206,7 +206,7 @@ func (f *NetFuncs) CIDRSubnets(newbits interface{}, prefix interface{}) ([]netip // CIDRSubnetSizes - // Experimental! -func (f *NetFuncs) CIDRSubnetSizes(args ...interface{}) ([]netip.Prefix, error) { +func (f *NetFuncs) CIDRSubnetSizes(args ...any) ([]netip.Prefix, error) { if err := checkExperimental(f.ctx); err != nil { return nil, err } diff --git a/internal/funcs/net_test.go b/internal/funcs/net_test.go index 018b75e5..4e1b120b 100644 --- a/internal/funcs/net_test.go +++ b/internal/funcs/net_test.go @@ -16,14 +16,14 @@ import ( func TestCreateNetFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateNetFuncs(ctx) - actual := fmap["net"].(func() interface{}) + actual := fmap["net"].(func() any) assert.Equal(t, ctx, actual().(*NetFuncs).ctx) }) diff --git a/internal/funcs/path.go b/internal/funcs/path.go index 3831ed5f..9c45f6f7 100644 --- a/internal/funcs/path.go +++ b/internal/funcs/path.go @@ -8,10 +8,10 @@ import ( ) // CreatePathFuncs - -func CreatePathFuncs(ctx context.Context) map[string]interface{} { +func CreatePathFuncs(ctx context.Context) map[string]any { ns := &PathFuncs{ctx} - return map[string]interface{}{ - "path": func() interface{} { return ns }, + return map[string]any{ + "path": func() any { return ns }, } } @@ -21,43 +21,43 @@ type PathFuncs struct { } // Base - -func (PathFuncs) Base(in interface{}) string { +func (PathFuncs) Base(in any) string { return path.Base(conv.ToString(in)) } // Clean - -func (PathFuncs) Clean(in interface{}) string { +func (PathFuncs) Clean(in any) string { return path.Clean(conv.ToString(in)) } // Dir - -func (PathFuncs) Dir(in interface{}) string { +func (PathFuncs) Dir(in any) string { return path.Dir(conv.ToString(in)) } // Ext - -func (PathFuncs) Ext(in interface{}) string { +func (PathFuncs) Ext(in any) string { return path.Ext(conv.ToString(in)) } // IsAbs - -func (PathFuncs) IsAbs(in interface{}) bool { +func (PathFuncs) IsAbs(in any) bool { return path.IsAbs(conv.ToString(in)) } // Join - -func (PathFuncs) Join(elem ...interface{}) string { +func (PathFuncs) Join(elem ...any) string { s := conv.ToStrings(elem...) return path.Join(s...) } // Match - -func (PathFuncs) Match(pattern, name interface{}) (matched bool, err error) { +func (PathFuncs) Match(pattern, name any) (matched bool, err error) { return path.Match(conv.ToString(pattern), conv.ToString(name)) } // Split - -func (PathFuncs) Split(in interface{}) []string { +func (PathFuncs) Split(in any) []string { dir, file := path.Split(conv.ToString(in)) return []string{dir, file} } diff --git a/internal/funcs/path_test.go b/internal/funcs/path_test.go index aa4d1322..4cb41911 100644 --- a/internal/funcs/path_test.go +++ b/internal/funcs/path_test.go @@ -11,14 +11,14 @@ import ( func TestCreatePathFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreatePathFuncs(ctx) - actual := fmap["path"].(func() interface{}) + actual := fmap["path"].(func() any) assert.Equal(t, ctx, actual().(*PathFuncs).ctx) }) diff --git a/internal/funcs/random.go b/internal/funcs/random.go index afadfef4..e6e54a38 100644 --- a/internal/funcs/random.go +++ b/internal/funcs/random.go @@ -12,10 +12,10 @@ import ( ) // CreateRandomFuncs - -func CreateRandomFuncs(ctx context.Context) map[string]interface{} { +func CreateRandomFuncs(ctx context.Context) map[string]any { ns := &RandomFuncs{ctx} - return map[string]interface{}{ - "random": func() interface{} { return ns }, + return map[string]any{ + "random": func() any { return ns }, } } @@ -25,7 +25,7 @@ type RandomFuncs struct { } // ASCII - -func (RandomFuncs) ASCII(count interface{}) (string, error) { +func (RandomFuncs) ASCII(count any) (string, error) { n, err := conv.ToInt(count) if err != nil { return "", fmt.Errorf("count must be an integer: %w", err) @@ -35,7 +35,7 @@ func (RandomFuncs) ASCII(count interface{}) (string, error) { } // Alpha - -func (RandomFuncs) Alpha(count interface{}) (string, error) { +func (RandomFuncs) Alpha(count any) (string, error) { n, err := conv.ToInt(count) if err != nil { return "", fmt.Errorf("count must be an integer: %w", err) @@ -45,7 +45,7 @@ func (RandomFuncs) Alpha(count interface{}) (string, error) { } // AlphaNum - -func (RandomFuncs) AlphaNum(count interface{}) (string, error) { +func (RandomFuncs) AlphaNum(count any) (string, error) { n, err := conv.ToInt(count) if err != nil { return "", fmt.Errorf("count must be an integer: %w", err) @@ -55,7 +55,7 @@ func (RandomFuncs) AlphaNum(count interface{}) (string, error) { } // String - -func (RandomFuncs) String(count interface{}, args ...interface{}) (string, error) { +func (RandomFuncs) String(count any, args ...any) (string, error) { c, err := conv.ToInt(count) if err != nil { return "", fmt.Errorf("count must be an integer: %w", err) @@ -98,7 +98,7 @@ func (RandomFuncs) String(count interface{}, args ...interface{}) (string, error return random.StringRE(c, m) } -func isString(s interface{}) bool { +func isString(s any) bool { switch s.(type) { case string: return true @@ -131,7 +131,7 @@ func toCodePoints(l, u string) (rune, rune, error) { } // Item - -func (RandomFuncs) Item(items interface{}) (interface{}, error) { +func (RandomFuncs) Item(items any) (any, error) { i, err := iconv.InterfaceSlice(items) if err != nil { return nil, err @@ -140,7 +140,7 @@ func (RandomFuncs) Item(items interface{}) (interface{}, error) { } // Number - -func (RandomFuncs) Number(args ...interface{}) (int64, error) { +func (RandomFuncs) Number(args ...any) (int64, error) { var nMin, nMax int64 nMin, nMax = 0, 100 @@ -169,7 +169,7 @@ func (RandomFuncs) Number(args ...interface{}) (int64, error) { } // Float - -func (RandomFuncs) Float(args ...interface{}) (float64, error) { +func (RandomFuncs) Float(args ...any) (float64, error) { var nMin, nMax float64 nMin, nMax = 0, 1.0 diff --git a/internal/funcs/random_test.go b/internal/funcs/random_test.go index c26c8ea7..d020079e 100644 --- a/internal/funcs/random_test.go +++ b/internal/funcs/random_test.go @@ -13,14 +13,14 @@ import ( func TestCreateRandomFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateRandomFuncs(ctx) - actual := fmap["random"].(func() interface{}) + actual := fmap["random"].(func() any) assert.Equal(t, ctx, actual().(*RandomFuncs).ctx) }) @@ -168,7 +168,7 @@ func TestItem(t *testing.T) { in := []string{"foo", "bar"} got := "" - for j := 0; j < 10; j++ { + for range 10 { i, err = f.Item(in) require.NoError(t, err) got += i.(string) diff --git a/internal/funcs/regexp.go b/internal/funcs/regexp.go index d7f6a685..e7091091 100644 --- a/internal/funcs/regexp.go +++ b/internal/funcs/regexp.go @@ -9,10 +9,10 @@ import ( ) // CreateReFuncs - -func CreateReFuncs(ctx context.Context) map[string]interface{} { +func CreateReFuncs(ctx context.Context) map[string]any { ns := &ReFuncs{ctx} - return map[string]interface{}{ - "regexp": func() interface{} { return ns }, + return map[string]any{ + "regexp": func() any { return ns }, } } @@ -22,12 +22,12 @@ type ReFuncs struct { } // Find - -func (ReFuncs) Find(re, input interface{}) (string, error) { +func (ReFuncs) Find(re, input any) (string, error) { return regexp.Find(conv.ToString(re), conv.ToString(input)) } // FindAll - -func (ReFuncs) FindAll(args ...interface{}) ([]string, error) { +func (ReFuncs) FindAll(args ...any) ([]string, error) { re := "" n := 0 input := "" @@ -55,31 +55,31 @@ func (ReFuncs) FindAll(args ...interface{}) ([]string, error) { } // Match - -func (ReFuncs) Match(re, input interface{}) (bool, error) { +func (ReFuncs) Match(re, input any) (bool, error) { return regexp.Match(conv.ToString(re), conv.ToString(input)) } // QuoteMeta - -func (ReFuncs) QuoteMeta(in interface{}) string { +func (ReFuncs) QuoteMeta(in any) string { return regexp.QuoteMeta(conv.ToString(in)) } // Replace - -func (ReFuncs) Replace(re, replacement, input interface{}) (string, error) { +func (ReFuncs) Replace(re, replacement, input any) (string, error) { return regexp.Replace(conv.ToString(re), conv.ToString(replacement), conv.ToString(input)) } // ReplaceLiteral - -func (ReFuncs) ReplaceLiteral(re, replacement, input interface{}) (string, error) { +func (ReFuncs) ReplaceLiteral(re, replacement, input any) (string, error) { return regexp.ReplaceLiteral(conv.ToString(re), conv.ToString(replacement), conv.ToString(input)) } // Split - -func (ReFuncs) Split(args ...interface{}) ([]string, error) { +func (ReFuncs) Split(args ...any) ([]string, error) { re := "" n := -1 input := "" diff --git a/internal/funcs/regexp_test.go b/internal/funcs/regexp_test.go index a3d30617..ac038eab 100644 --- a/internal/funcs/regexp_test.go +++ b/internal/funcs/regexp_test.go @@ -12,14 +12,14 @@ import ( func TestCreateReFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateReFuncs(ctx) - actual := fmap["regexp"].(func() interface{}) + actual := fmap["regexp"].(func() any) assert.Equal(t, ctx, actual().(*ReFuncs).ctx) }) diff --git a/internal/funcs/semver.go b/internal/funcs/semver.go index 0212c998..b4c6c203 100644 --- a/internal/funcs/semver.go +++ b/internal/funcs/semver.go @@ -7,10 +7,10 @@ import ( ) // CreateSemverFuncs - -func CreateSemverFuncs(ctx context.Context) map[string]interface{} { +func CreateSemverFuncs(ctx context.Context) map[string]any { ns := &SemverFuncs{ctx} - return map[string]interface{}{ - "semver": func() interface{} { return ns }, + return map[string]any{ + "semver": func() any { return ns }, } } diff --git a/internal/funcs/sockaddr.go b/internal/funcs/sockaddr.go index a1e607ec..b6a86643 100644 --- a/internal/funcs/sockaddr.go +++ b/internal/funcs/sockaddr.go @@ -8,10 +8,10 @@ import ( ) // CreateSockaddrFuncs - -func CreateSockaddrFuncs(ctx context.Context) map[string]interface{} { +func CreateSockaddrFuncs(ctx context.Context) map[string]any { ns := &SockaddrFuncs{ctx} - return map[string]interface{}{ - "sockaddr": func() interface{} { return ns }, + return map[string]any{ + "sockaddr": func() any { return ns }, } } @@ -56,7 +56,7 @@ func (SockaddrFuncs) Include(selectorName, selectorParam string, inputIfAddrs so } // Attr - -func (SockaddrFuncs) Attr(selectorName string, ifAddrsRaw interface{}) (string, error) { +func (SockaddrFuncs) Attr(selectorName string, ifAddrsRaw any) (string, error) { return template.Attr(selectorName, ifAddrsRaw) } diff --git a/internal/funcs/sockaddr_test.go b/internal/funcs/sockaddr_test.go index caf86bf8..d4602f6b 100644 --- a/internal/funcs/sockaddr_test.go +++ b/internal/funcs/sockaddr_test.go @@ -11,14 +11,14 @@ import ( func TestCreateSockaddrFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateSockaddrFuncs(ctx) - actual := fmap["sockaddr"].(func() interface{}) + actual := fmap["sockaddr"].(func() any) assert.Equal(t, ctx, actual().(*SockaddrFuncs).ctx) }) diff --git a/internal/funcs/strings.go b/internal/funcs/strings.go index 8b27ad19..f5f7fc1d 100644 --- a/internal/funcs/strings.go +++ b/internal/funcs/strings.go @@ -24,11 +24,11 @@ import ( ) // CreateStringFuncs - -func CreateStringFuncs(ctx context.Context) map[string]interface{} { - f := map[string]interface{}{} +func CreateStringFuncs(ctx context.Context) map[string]any { + f := map[string]any{} ns := &StringFuncs{ctx, language.Und} - f["strings"] = func() interface{} { return ns } + f["strings"] = func() any { return ns } f["replaceAll"] = ns.ReplaceAll f["title"] = ns.Title @@ -113,7 +113,7 @@ func (f *StringFuncs) oldTrim(s, cutset string) string { // ---- // Abbrev - -func (StringFuncs) Abbrev(args ...interface{}) (string, error) { +func (StringFuncs) Abbrev(args ...any) (string, error) { str := "" offset := 0 width := 0 @@ -154,27 +154,27 @@ func (StringFuncs) Abbrev(args ...interface{}) (string, error) { // ReplaceAll - // //nolint:revive -func (StringFuncs) ReplaceAll(old, new string, s interface{}) string { +func (StringFuncs) ReplaceAll(old, new string, s any) string { return strings.ReplaceAll(conv.ToString(s), old, new) } // Contains - -func (StringFuncs) Contains(substr string, s interface{}) bool { +func (StringFuncs) Contains(substr string, s any) bool { return strings.Contains(conv.ToString(s), substr) } // HasPrefix - -func (StringFuncs) HasPrefix(prefix string, s interface{}) bool { +func (StringFuncs) HasPrefix(prefix string, s any) bool { return strings.HasPrefix(conv.ToString(s), prefix) } // HasSuffix - -func (StringFuncs) HasSuffix(suffix string, s interface{}) bool { +func (StringFuncs) HasSuffix(suffix string, s any) bool { return strings.HasSuffix(conv.ToString(s), suffix) } // Repeat - -func (StringFuncs) Repeat(count int, s interface{}) (string, error) { +func (StringFuncs) Repeat(count int, s any) (string, error) { if count < 0 { return "", fmt.Errorf("negative count %d", count) } @@ -193,16 +193,16 @@ func (StringFuncs) SkipLines(skip int, in string) (string, error) { // Sort - // // Deprecated: use [CollFuncs.Sort] instead -func (f *StringFuncs) Sort(list interface{}) ([]string, error) { +func (f *StringFuncs) Sort(list any) ([]string, error) { deprecated.WarnDeprecated(f.ctx, "strings.Sort is deprecated - use coll.Sort instead") switch v := list.(type) { case []string: return gompstrings.Sort(v), nil - case []interface{}: + case []any: l := len(v) b := make([]string, len(v)) - for i := 0; i < l; i++ { + for i := range l { b[i] = conv.ToString(v[i]) } return gompstrings.Sort(b), nil @@ -212,67 +212,67 @@ func (f *StringFuncs) Sort(list interface{}) ([]string, error) { } // Split - -func (StringFuncs) Split(sep string, s interface{}) []string { +func (StringFuncs) Split(sep string, s any) []string { return strings.Split(conv.ToString(s), sep) } // SplitN - -func (StringFuncs) SplitN(sep string, n int, s interface{}) []string { +func (StringFuncs) SplitN(sep string, n int, s any) []string { return strings.SplitN(conv.ToString(s), sep, n) } // Trim - -func (StringFuncs) Trim(cutset string, s interface{}) string { +func (StringFuncs) Trim(cutset string, s any) string { return strings.Trim(conv.ToString(s), cutset) } // TrimLeft - -func (StringFuncs) TrimLeft(cutset string, s interface{}) string { +func (StringFuncs) TrimLeft(cutset string, s any) string { return strings.TrimLeft(conv.ToString(s), cutset) } // TrimPrefix - -func (StringFuncs) TrimPrefix(cutset string, s interface{}) string { +func (StringFuncs) TrimPrefix(cutset string, s any) string { return strings.TrimPrefix(conv.ToString(s), cutset) } // TrimRight - -func (StringFuncs) TrimRight(cutset string, s interface{}) string { +func (StringFuncs) TrimRight(cutset string, s any) string { return strings.TrimRight(conv.ToString(s), cutset) } // TrimSuffix - -func (StringFuncs) TrimSuffix(cutset string, s interface{}) string { +func (StringFuncs) TrimSuffix(cutset string, s any) string { return strings.TrimSuffix(conv.ToString(s), cutset) } // Title - -func (f *StringFuncs) Title(s interface{}) string { +func (f *StringFuncs) Title(s any) string { return cases.Title(f.tag, cases.NoLower).String(conv.ToString(s)) } // ToUpper - -func (f *StringFuncs) ToUpper(s interface{}) string { +func (f *StringFuncs) ToUpper(s any) string { return cases.Upper(f.tag).String(conv.ToString(s)) } // ToLower - -func (f *StringFuncs) ToLower(s interface{}) string { +func (f *StringFuncs) ToLower(s any) string { return cases.Lower(f.tag).String(conv.ToString(s)) } // TrimSpace - -func (StringFuncs) TrimSpace(s interface{}) string { +func (StringFuncs) TrimSpace(s any) string { return strings.TrimSpace(conv.ToString(s)) } // Trunc - -func (StringFuncs) Trunc(length int, s interface{}) string { +func (StringFuncs) Trunc(length int, s any) string { return gompstrings.Trunc(length, conv.ToString(s)) } // Indent - -func (StringFuncs) Indent(args ...interface{}) (string, error) { +func (StringFuncs) Indent(args ...any) (string, error) { indent := " " width := 1 @@ -309,23 +309,23 @@ func (StringFuncs) Indent(args ...interface{}) (string, error) { } // Slug - -func (StringFuncs) Slug(in interface{}) string { +func (StringFuncs) Slug(in any) string { return slug.Make(conv.ToString(in)) } // Quote - -func (StringFuncs) Quote(in interface{}) string { +func (StringFuncs) Quote(in any) string { return fmt.Sprintf("%q", conv.ToString(in)) } // ShellQuote - -func (StringFuncs) ShellQuote(in interface{}) string { +func (StringFuncs) ShellQuote(in any) string { val := reflect.ValueOf(in) switch val.Kind() { case reflect.Array, reflect.Slice: var sb strings.Builder vLen := val.Len() - for n := 0; n < vLen; n++ { + for n := range vLen { sb.WriteString(gompstrings.ShellQuote(conv.ToString(val.Index(n)))) if n+1 != vLen { sb.WriteRune(' ') @@ -337,29 +337,29 @@ func (StringFuncs) ShellQuote(in interface{}) string { } // Squote - -func (StringFuncs) Squote(in interface{}) string { +func (StringFuncs) Squote(in any) string { s := conv.ToString(in) s = strings.ReplaceAll(s, `'`, `''`) return fmt.Sprintf("'%s'", s) } // SnakeCase - -func (StringFuncs) SnakeCase(in interface{}) (string, error) { +func (StringFuncs) SnakeCase(in any) (string, error) { return gompstrings.SnakeCase(conv.ToString(in)), nil } // CamelCase - -func (StringFuncs) CamelCase(in interface{}) (string, error) { +func (StringFuncs) CamelCase(in any) (string, error) { return gompstrings.CamelCase(conv.ToString(in)), nil } // KebabCase - -func (StringFuncs) KebabCase(in interface{}) (string, error) { +func (StringFuncs) KebabCase(in any) (string, error) { return gompstrings.KebabCase(conv.ToString(in)), nil } // WordWrap - -func (StringFuncs) WordWrap(args ...interface{}) (string, error) { +func (StringFuncs) WordWrap(args ...any) (string, error) { if len(args) == 0 || len(args) > 3 { return "", fmt.Errorf("expected 1, 2, or 3 args, got %d", len(args)) } @@ -404,7 +404,7 @@ func (StringFuncs) WordWrap(args ...interface{}) (string, error) { } // RuneCount - like len(s), but for runes -func (StringFuncs) RuneCount(args ...interface{}) (int, error) { +func (StringFuncs) RuneCount(args ...any) (int, error) { s := "" for _, arg := range args { s += conv.ToString(arg) diff --git a/internal/funcs/strings_test.go b/internal/funcs/strings_test.go index 032e45e3..0194d446 100644 --- a/internal/funcs/strings_test.go +++ b/internal/funcs/strings_test.go @@ -12,14 +12,14 @@ import ( func TestCreateStringFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateStringFuncs(ctx) - actual := fmap["strings"].(func() interface{}) + actual := fmap["strings"].(func() any) assert.Equal(t, ctx, actual().(*StringFuncs).ctx) }) @@ -44,12 +44,12 @@ func TestIndent(t *testing.T) { testdata := []struct { out string - args []interface{} + args []any }{ - {" foo\n bar\n baz", []interface{}{"foo\nbar\nbaz"}}, - {" foo\n bar\n baz", []interface{}{" ", "foo\nbar\nbaz"}}, - {"---foo\n---bar\n---baz", []interface{}{3, "-", "foo\nbar\nbaz"}}, - {" foo\n bar\n baz", []interface{}{3, "foo\nbar\nbaz"}}, + {" foo\n bar\n baz", []any{"foo\nbar\nbaz"}}, + {" foo\n bar\n baz", []any{" ", "foo\nbar\nbaz"}}, + {"---foo\n---bar\n---baz", []any{3, "-", "foo\nbar\nbaz"}}, + {" foo\n bar\n baz", []any{3, "foo\nbar\nbaz"}}, } for _, d := range testdata { @@ -71,7 +71,7 @@ func TestTrimPrefix(t *testing.T) { func TestTitle(t *testing.T) { sf := &StringFuncs{} testdata := []struct { - in interface{} + in any out string }{ {``, ``}, @@ -158,7 +158,7 @@ func TestSort(t *testing.T) { out := []string{"bar", "baz", "foo"} assert.Equal(t, out, must(sf.Sort(in))) - assert.Equal(t, out, must(sf.Sort([]interface{}{"foo", "bar", "baz"}))) + assert.Equal(t, out, must(sf.Sort([]any{"foo", "bar", "baz"}))) } func TestQuote(t *testing.T) { @@ -166,7 +166,7 @@ func TestQuote(t *testing.T) { sf := &StringFuncs{} testdata := []struct { - in interface{} + in any out string }{ {``, `""`}, @@ -187,7 +187,7 @@ func TestShellQuote(t *testing.T) { sf := &StringFuncs{} testdata := []struct { - in interface{} + in any out string }{ // conventional cases are covered in gompstrings.ShellQuote() tests @@ -211,7 +211,7 @@ func TestSquote(t *testing.T) { sf := &StringFuncs{} testdata := []struct { - in interface{} + in any out string }{ {``, `''`}, @@ -263,7 +263,7 @@ func TestTrimLeft(t *testing.T) { sf := &StringFuncs{} testdata := []struct { - in interface{} + in any cutset string out string }{ @@ -287,7 +287,7 @@ func TestTrimRight(t *testing.T) { sf := &StringFuncs{} testdata := []struct { - in interface{} + in any cutset string out string }{ diff --git a/internal/funcs/test.go b/internal/funcs/test.go index 9dd780e5..9f14c5af 100644 --- a/internal/funcs/test.go +++ b/internal/funcs/test.go @@ -10,11 +10,11 @@ import ( ) // CreateTestFuncs - -func CreateTestFuncs(ctx context.Context) map[string]interface{} { - f := map[string]interface{}{} +func CreateTestFuncs(ctx context.Context) map[string]any { + f := map[string]any{} ns := &TestFuncs{ctx} - f["test"] = func() interface{} { return ns } + f["test"] = func() any { return ns } f["assert"] = ns.Assert f["fail"] = ns.Fail @@ -31,7 +31,7 @@ type TestFuncs struct { } // Assert - -func (TestFuncs) Assert(args ...interface{}) (string, error) { +func (TestFuncs) Assert(args ...any) (string, error) { input := conv.ToBool(args[len(args)-1]) switch len(args) { case 1: @@ -48,7 +48,7 @@ func (TestFuncs) Assert(args ...interface{}) (string, error) { } // Fail - -func (TestFuncs) Fail(args ...interface{}) (string, error) { +func (TestFuncs) Fail(args ...any) (string, error) { switch len(args) { case 0: return "", test.Fail("") @@ -60,7 +60,7 @@ func (TestFuncs) Fail(args ...interface{}) (string, error) { } // Required - -func (TestFuncs) Required(args ...interface{}) (interface{}, error) { +func (TestFuncs) Required(args ...any) (any, error) { switch len(args) { case 1: return test.Required("", args[0]) @@ -76,7 +76,7 @@ func (TestFuncs) Required(args ...interface{}) (interface{}, error) { } // Ternary - -func (TestFuncs) Ternary(tval, fval, b interface{}) interface{} { +func (TestFuncs) Ternary(tval, fval, b any) any { if conv.ToBool(b) { return tval } @@ -84,12 +84,12 @@ func (TestFuncs) Ternary(tval, fval, b interface{}) interface{} { } // Kind - return the kind of the argument -func (TestFuncs) Kind(arg interface{}) string { +func (TestFuncs) Kind(arg any) string { return reflect.ValueOf(arg).Kind().String() } // IsKind - return whether or not the argument is of the given kind -func (f TestFuncs) IsKind(kind string, arg interface{}) bool { +func (f TestFuncs) IsKind(kind string, arg any) bool { k := f.Kind(arg) if kind == "number" { switch k { diff --git a/internal/funcs/test_test.go b/internal/funcs/test_test.go index 98ae6753..4ce5d9b7 100644 --- a/internal/funcs/test_test.go +++ b/internal/funcs/test_test.go @@ -12,14 +12,14 @@ import ( func TestCreateTestFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateTestFuncs(ctx) - actual := fmap["test"].(func() interface{}) + actual := fmap["test"].(func() any) assert.Equal(t, ctx, actual().(*TestFuncs).ctx) }) @@ -93,8 +93,8 @@ func TestTernary(t *testing.T) { f := TestFuncs{ctx: context.Background()} testdata := []struct { - tval, fval, b interface{} - expected interface{} + tval, fval, b any + expected any }{ {"foo", 42, false, 42}, {"foo", 42, "yes", "foo"}, @@ -110,7 +110,7 @@ func TestKind(t *testing.T) { f := TestFuncs{ctx: context.Background()} testdata := []struct { - arg interface{} + arg any expected string }{ {"foo", "string"}, @@ -133,7 +133,7 @@ func TestIsKind(t *testing.T) { f := TestFuncs{ctx: context.Background()} truedata := []struct { - arg interface{} + arg any kind string }{ {"foo", "string"}, @@ -155,7 +155,7 @@ func TestIsKind(t *testing.T) { } falsedata := []struct { - arg interface{} + arg any kind string }{ {"foo", "bool"}, diff --git a/internal/funcs/time.go b/internal/funcs/time.go index fa2f6424..08217412 100644 --- a/internal/funcs/time.go +++ b/internal/funcs/time.go @@ -14,7 +14,7 @@ import ( ) // CreateTimeFuncs - -func CreateTimeFuncs(ctx context.Context) map[string]interface{} { +func CreateTimeFuncs(ctx context.Context) map[string]any { ns := &TimeFuncs{ ctx: ctx, ANSIC: gotime.ANSIC, @@ -34,8 +34,8 @@ func CreateTimeFuncs(ctx context.Context) map[string]interface{} { StampNano: gotime.StampNano, } - return map[string]interface{}{ - "time": func() interface{} { return ns }, + return map[string]any{ + "time": func() any { return ns }, } } @@ -70,18 +70,18 @@ func (TimeFuncs) ZoneOffset() int { } // Parse - -func (TimeFuncs) Parse(layout string, value interface{}) (gotime.Time, error) { +func (TimeFuncs) Parse(layout string, value any) (gotime.Time, error) { return gotime.Parse(layout, conv.ToString(value)) } // ParseLocal - -func (f TimeFuncs) ParseLocal(layout string, value interface{}) (gotime.Time, error) { +func (f TimeFuncs) ParseLocal(layout string, value any) (gotime.Time, error) { tz := env.Getenv("TZ", "Local") return f.ParseInLocation(layout, tz, value) } // ParseInLocation - -func (TimeFuncs) ParseInLocation(layout, location string, value interface{}) (gotime.Time, error) { +func (TimeFuncs) ParseInLocation(layout, location string, value any) (gotime.Time, error) { loc, err := gotime.LoadLocation(location) if err != nil { return gotime.Time{}, err @@ -96,7 +96,7 @@ func (TimeFuncs) Now() gotime.Time { // Unix - convert UNIX time (in seconds since the UNIX epoch) into a time.Time for further processing // Takes a string or number (int or float) -func (TimeFuncs) Unix(in interface{}) (gotime.Time, error) { +func (TimeFuncs) Unix(in any) (gotime.Time, error) { sec, nsec, err := parseNum(in) if err != nil { return gotime.Time{}, err @@ -105,7 +105,7 @@ func (TimeFuncs) Unix(in interface{}) (gotime.Time, error) { } // Nanosecond - -func (TimeFuncs) Nanosecond(n interface{}) (gotime.Duration, error) { +func (TimeFuncs) Nanosecond(n any) (gotime.Duration, error) { in, err := conv.ToInt64(n) if err != nil { return 0, fmt.Errorf("expected a number: %w", err) @@ -115,7 +115,7 @@ func (TimeFuncs) Nanosecond(n interface{}) (gotime.Duration, error) { } // Microsecond - -func (TimeFuncs) Microsecond(n interface{}) (gotime.Duration, error) { +func (TimeFuncs) Microsecond(n any) (gotime.Duration, error) { in, err := conv.ToInt64(n) if err != nil { return 0, fmt.Errorf("expected a number: %w", err) @@ -125,7 +125,7 @@ func (TimeFuncs) Microsecond(n interface{}) (gotime.Duration, error) { } // Millisecond - -func (TimeFuncs) Millisecond(n interface{}) (gotime.Duration, error) { +func (TimeFuncs) Millisecond(n any) (gotime.Duration, error) { in, err := conv.ToInt64(n) if err != nil { return 0, fmt.Errorf("expected a number: %w", err) @@ -135,7 +135,7 @@ func (TimeFuncs) Millisecond(n interface{}) (gotime.Duration, error) { } // Second - -func (TimeFuncs) Second(n interface{}) (gotime.Duration, error) { +func (TimeFuncs) Second(n any) (gotime.Duration, error) { in, err := conv.ToInt64(n) if err != nil { return 0, fmt.Errorf("expected a number: %w", err) @@ -145,7 +145,7 @@ func (TimeFuncs) Second(n interface{}) (gotime.Duration, error) { } // Minute - -func (TimeFuncs) Minute(n interface{}) (gotime.Duration, error) { +func (TimeFuncs) Minute(n any) (gotime.Duration, error) { in, err := conv.ToInt64(n) if err != nil { return 0, fmt.Errorf("expected a number: %w", err) @@ -155,7 +155,7 @@ func (TimeFuncs) Minute(n interface{}) (gotime.Duration, error) { } // Hour - -func (TimeFuncs) Hour(n interface{}) (gotime.Duration, error) { +func (TimeFuncs) Hour(n any) (gotime.Duration, error) { in, err := conv.ToInt64(n) if err != nil { return 0, fmt.Errorf("expected a number: %w", err) @@ -165,7 +165,7 @@ func (TimeFuncs) Hour(n interface{}) (gotime.Duration, error) { } // ParseDuration - -func (TimeFuncs) ParseDuration(n interface{}) (gotime.Duration, error) { +func (TimeFuncs) ParseDuration(n any) (gotime.Duration, error) { return gotime.ParseDuration(conv.ToString(n)) } @@ -182,7 +182,7 @@ func (TimeFuncs) Until(n gotime.Time) gotime.Duration { // convert a number input to a pair of int64s, representing the integer portion and the decimal remainder // this can handle a string as well as any integer or float type // precision is at the "nano" level (i.e. 1e+9) -func parseNum(in interface{}) (integral int64, fractional int64, err error) { +func parseNum(in any) (integral int64, fractional int64, err error) { if s, ok := in.(string); ok { ss := strings.Split(s, ".") if len(ss) > 2 { diff --git a/internal/funcs/time_test.go b/internal/funcs/time_test.go index 8d229025..f24a99b6 100644 --- a/internal/funcs/time_test.go +++ b/internal/funcs/time_test.go @@ -14,14 +14,14 @@ import ( func TestCreateTimeFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateTimeFuncs(ctx) - actual := fmap["time"].(func() interface{}) + actual := fmap["time"].(func() any) assert.Equal(t, ctx, actual().(*TimeFuncs).ctx) }) diff --git a/internal/funcs/uuid.go b/internal/funcs/uuid.go index 6831dbf7..097c5b4d 100644 --- a/internal/funcs/uuid.go +++ b/internal/funcs/uuid.go @@ -9,10 +9,10 @@ import ( ) // CreateUUIDFuncs - -func CreateUUIDFuncs(ctx context.Context) map[string]interface{} { +func CreateUUIDFuncs(ctx context.Context) map[string]any { ns := &UUIDFuncs{ctx} - return map[string]interface{}{ - "uuid": func() interface{} { return ns }, + return map[string]any{ + "uuid": func() any { return ns }, } } @@ -47,7 +47,7 @@ func (UUIDFuncs) Nil() (string, error) { // IsValid - checks if the given UUID is in the correct format. It does not // validate whether the version or variant are correct. -func (f UUIDFuncs) IsValid(in interface{}) (bool, error) { +func (f UUIDFuncs) IsValid(in any) (bool, error) { _, err := f.Parse(in) return err == nil, nil } @@ -58,7 +58,7 @@ func (f UUIDFuncs) IsValid(in interface{}) (bool, error) { // urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx are decoded as well as the // Microsoft encoding {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx} and the raw hex // encoding: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx. -func (UUIDFuncs) Parse(in interface{}) (uuid.UUID, error) { +func (UUIDFuncs) Parse(in any) (uuid.UUID, error) { u, err := uuid.Parse(conv.ToString(in)) if err != nil { return uuid.Nil, err diff --git a/internal/funcs/uuid_test.go b/internal/funcs/uuid_test.go index 57d5c63b..627b384e 100644 --- a/internal/funcs/uuid_test.go +++ b/internal/funcs/uuid_test.go @@ -13,14 +13,14 @@ import ( func TestCreateUUIDFuncs(t *testing.T) { t.Parallel() - for i := 0; i < 10; i++ { + for i := range 10 { // Run this a bunch to catch race conditions t.Run(strconv.Itoa(i), func(t *testing.T) { t.Parallel() ctx := context.Background() fmap := CreateUUIDFuncs(ctx) - actual := fmap["uuid"].(func() interface{}) + actual := fmap["uuid"].(func() any) assert.Equal(t, ctx, actual().(*UUIDFuncs).ctx) }) @@ -63,7 +63,7 @@ func TestIsValid(t *testing.T) { t.Parallel() u := UUIDFuncs{ctx: context.Background()} - in := interface{}(false) + in := any(false) i, err := u.IsValid(in) require.NoError(t, err) assert.False(t, i) @@ -73,7 +73,7 @@ func TestIsValid(t *testing.T) { require.NoError(t, err) assert.False(t, i) - testdata := []interface{}{ + testdata := []any{ "123456781234123412341234567890ab", "12345678-1234-1234-1234-1234567890ab", "urn:uuid:12345678-1234-1234-1234-1234567890ab", @@ -91,7 +91,7 @@ func TestParse(t *testing.T) { t.Parallel() u := UUIDFuncs{ctx: context.Background()} - in := interface{}(false) + in := any(false) _, err := u.Parse(in) require.Error(t, err) @@ -100,7 +100,7 @@ func TestParse(t *testing.T) { require.Error(t, err) in = "12345678-1234-1234-1234-1234567890ab" - testdata := []interface{}{ + testdata := []any{ "123456781234123412341234567890ab", "12345678-1234-1234-1234-1234567890ab", "urn:uuid:12345678-1234-1234-1234-1234567890ab", diff --git a/internal/parsers/parsefuncs.go b/internal/parsers/parsefuncs.go index c16f86e7..0a309ab2 100644 --- a/internal/parsers/parsefuncs.go +++ b/internal/parsers/parsefuncs.go @@ -25,7 +25,7 @@ import ( "github.com/hairyhenderson/yaml" ) -func unmarshalObj(obj map[string]interface{}, in string, f func([]byte, interface{}) error) (map[string]interface{}, error) { +func unmarshalObj(obj map[string]any, in string, f func([]byte, any) error) (map[string]any, error) { err := f([]byte(in), &obj) if err != nil { return nil, fmt.Errorf("unable to unmarshal object %s: %w", in, err) @@ -33,7 +33,7 @@ func unmarshalObj(obj map[string]interface{}, in string, f func([]byte, interfac return obj, nil } -func unmarshalArray(obj []interface{}, in string, f func([]byte, interface{}) error) ([]interface{}, error) { +func unmarshalArray(obj []any, in string, f func([]byte, any) error) ([]any, error) { err := f([]byte(in), &obj) if err != nil { return nil, fmt.Errorf("unable to unmarshal array %s: %w", in, err) @@ -42,8 +42,8 @@ func unmarshalArray(obj []interface{}, in string, f func([]byte, interface{}) er } // JSON - Unmarshal a JSON Object. Can be ejson-encrypted. -func JSON(in string) (map[string]interface{}, error) { - obj := make(map[string]interface{}) +func JSON(in string) (map[string]any, error) { + obj := make(map[string]any) out, err := unmarshalObj(obj, in, yaml.Unmarshal) if err != nil { return out, err @@ -57,7 +57,7 @@ func JSON(in string) (map[string]interface{}, error) { } // decryptEJSON - decrypts an ejson input, and unmarshals it, stripping the _public_key field. -func decryptEJSON(in string) (map[string]interface{}, error) { +func decryptEJSON(in string) (map[string]any, error) { keyDir := getenv("EJSON_KEYDIR", "/opt/ejson/keys") key := getenv("EJSON_KEY") @@ -67,7 +67,7 @@ func decryptEJSON(in string) (map[string]interface{}, error) { if err != nil { return nil, err } - obj := make(map[string]interface{}) + obj := make(map[string]any) out, err := unmarshalObj(obj, rOut.String(), yaml.Unmarshal) if err != nil { return nil, err @@ -101,14 +101,14 @@ func getenv(key string, def ...string) string { } // JSONArray - Unmarshal a JSON Array -func JSONArray(in string) ([]interface{}, error) { - obj := make([]interface{}, 1) +func JSONArray(in string) ([]any, error) { + obj := make([]any, 1) return unmarshalArray(obj, in, yaml.Unmarshal) } // YAML - Unmarshal a YAML Object -func YAML(in string) (map[string]interface{}, error) { - obj := make(map[string]interface{}) +func YAML(in string) (map[string]any, error) { + obj := make(map[string]any) s := strings.NewReader(in) d := yaml.NewDecoder(s) for { @@ -129,8 +129,8 @@ func YAML(in string) (map[string]interface{}, error) { } // YAMLArray - Unmarshal a YAML Array -func YAMLArray(in string) ([]interface{}, error) { - obj := make([]interface{}, 1) +func YAMLArray(in string) ([]any, error) { + obj := make([]any, 1) s := strings.NewReader(in) d := yaml.NewDecoder(s) for { @@ -151,7 +151,7 @@ func YAMLArray(in string) ([]interface{}, error) { // stringifyYAMLArrayMapKeys recurses into the input array and changes all // non-string map keys to string map keys. Modifies the input array. -func stringifyYAMLArrayMapKeys(in []interface{}) error { +func stringifyYAMLArrayMapKeys(in []any) error { if _, changed := stringifyMapKeys(in); changed { return fmt.Errorf("stringifyYAMLArrayMapKeys: output type did not match input type, this should be impossible") } @@ -160,7 +160,7 @@ func stringifyYAMLArrayMapKeys(in []interface{}) error { // stringifyYAMLMapMapKeys recurses into the input map and changes all // non-string map keys to string map keys. Modifies the input map. -func stringifyYAMLMapMapKeys(in map[string]interface{}) error { +func stringifyYAMLMapMapKeys(in map[string]any) error { if _, changed := stringifyMapKeys(in); changed { return fmt.Errorf("stringifyYAMLMapMapKeys: output type did not match input type, this should be impossible") } @@ -168,28 +168,28 @@ func stringifyYAMLMapMapKeys(in map[string]interface{}) error { } // stringifyMapKeys recurses into in and changes all instances of -// map[interface{}]interface{} to map[string]interface{}. This is useful to +// map[any]any to map[string]any. This is useful to // work around the impedance mismatch between JSON and YAML unmarshaling that's // described here: https://github.com/go-yaml/yaml/issues/139 // // Taken and modified from https://github.com/gohugoio/hugo/blob/cdfd1c99baa22d69e865294dfcd783811f96c880/parser/metadecoders/decoder.go#L257, Apache License 2.0 // Originally inspired by https://github.com/stripe/stripe-mock/blob/24a2bb46a49b2a416cfea4150ab95781f69ee145/mapstr.go#L13, MIT License -func stringifyMapKeys(in interface{}) (interface{}, bool) { +func stringifyMapKeys(in any) (any, bool) { switch in := in.(type) { - case []interface{}: + case []any: for i, v := range in { if vv, replaced := stringifyMapKeys(v); replaced { in[i] = vv } } - case map[string]interface{}: + case map[string]any: for k, v := range in { if vv, changed := stringifyMapKeys(v); changed { in[k] = vv } } - case map[interface{}]interface{}: - res := make(map[string]interface{}) + case map[any]any: + res := make(map[string]any) for k, v := range in { ks := conv.ToString(k) @@ -206,18 +206,18 @@ func stringifyMapKeys(in interface{}) (interface{}, bool) { } // TOML - Unmarshal a TOML Object -func TOML(in string) (interface{}, error) { - obj := make(map[string]interface{}) +func TOML(in string) (any, error) { + obj := make(map[string]any) return unmarshalObj(obj, in, toml.Unmarshal) } // DotEnv - Unmarshal a dotenv file -func DotEnv(in string) (interface{}, error) { +func DotEnv(in string) (any, error) { env, err := godotenv.Unmarshal(in) if err != nil { return nil, err } - out := make(map[string]interface{}) + out := make(map[string]any) for k, v := range env { out[k] = v } @@ -352,7 +352,7 @@ func CSVByColumn(args ...string) (cols map[string][]string, err error) { } // ToCSV - -func ToCSV(args ...interface{}) (string, error) { +func ToCSV(args ...any) (string, error) { delim := "," var in [][]string if len(args) == 2 { @@ -367,22 +367,22 @@ func ToCSV(args ...interface{}) (string, error) { switch a := args[0].(type) { case [][]string: in = a - case [][]interface{}: + case [][]any: in = make([][]string, len(a)) for i, v := range a { in[i] = conv.ToStrings(v...) } - case []interface{}: + case []any: in = make([][]string, len(a)) for i, v := range a { - ar, ok := v.([]interface{}) + ar, ok := v.([]any) if !ok { - return "", fmt.Errorf("can't parse ToCSV input - must be a two-dimensional array (like [][]string or [][]interface{}) (was %T)", args[0]) + return "", fmt.Errorf("can't parse ToCSV input - must be a two-dimensional array (like [][]string or [][]any) (was %T)", args[0]) } in[i] = conv.ToStrings(ar...) } default: - return "", fmt.Errorf("can't parse ToCSV input - must be a two-dimensional array (like [][]string or [][]interface{}) (was %T)", args[0]) + return "", fmt.Errorf("can't parse ToCSV input - must be a two-dimensional array (like [][]string or [][]any) (was %T)", args[0]) } } b := &bytes.Buffer{} @@ -397,7 +397,7 @@ func ToCSV(args ...interface{}) (string, error) { return b.String(), nil } -func marshalObj(obj interface{}, f func(interface{}) ([]byte, error)) (string, error) { +func marshalObj(obj any, f func(any) ([]byte, error)) (string, error) { b, err := f(obj) if err != nil { return "", fmt.Errorf("unable to marshal object %s: %w", obj, err) @@ -406,7 +406,7 @@ func marshalObj(obj interface{}, f func(interface{}) ([]byte, error)) (string, e return string(b), nil } -func toJSONBytes(in interface{}) ([]byte, error) { +func toJSONBytes(in any) ([]byte, error) { h := &codec.JsonHandle{} h.Canonical = true buf := new(bytes.Buffer) @@ -418,7 +418,7 @@ func toJSONBytes(in interface{}) ([]byte, error) { } // ToJSON - Stringify a struct as JSON -func ToJSON(in interface{}) (string, error) { +func ToJSON(in any) (string, error) { s, err := toJSONBytes(in) if err != nil { return "", err @@ -427,7 +427,7 @@ func ToJSON(in interface{}) (string, error) { } // ToJSONPretty - Stringify a struct as JSON (indented) -func ToJSONPretty(indent string, in interface{}) (string, error) { +func ToJSONPretty(indent string, in any) (string, error) { out := new(bytes.Buffer) b, err := toJSONBytes(in) if err != nil { @@ -442,10 +442,10 @@ func ToJSONPretty(indent string, in interface{}) (string, error) { } // ToYAML - Stringify a struct as YAML -func ToYAML(in interface{}) (string, error) { +func ToYAML(in any) (string, error) { // I'd use yaml.Marshal, but between v2 and v3 the indent has changed from // 2 to 4. This explicitly sets it back to 2. - marshal := func(in interface{}) (out []byte, err error) { + marshal := func(in any) (out []byte, err error) { buf := &bytes.Buffer{} e := yaml.NewEncoder(buf) e.SetIndent(2) @@ -458,7 +458,7 @@ func ToYAML(in interface{}) (string, error) { } // ToTOML - Stringify a struct as TOML -func ToTOML(in interface{}) (string, error) { +func ToTOML(in any) (string, error) { buf := new(bytes.Buffer) err := toml.NewEncoder(buf).Encode(in) if err != nil { @@ -468,7 +468,7 @@ func ToTOML(in interface{}) (string, error) { } // CUE - Unmarshal a CUE expression into the appropriate type -func CUE(in string) (interface{}, error) { +func CUE(in string) (any, error) { cuectx := cuecontext.New() val := cuectx.CompileString(in) @@ -478,11 +478,11 @@ func CUE(in string) (interface{}, error) { switch val.Kind() { case cue.StructKind: - out := map[string]interface{}{} + out := map[string]any{} err := val.Decode(&out) return out, err case cue.ListKind: - out := []interface{}{} + out := []any{} err := val.Decode(&out) return out, err case cue.BytesKind: @@ -512,7 +512,7 @@ func CUE(in string) (interface{}, error) { } } -func ToCUE(in interface{}) (string, error) { +func ToCUE(in any) (string, error) { cuectx := cuecontext.New() v := cuectx.Encode(in) if v.Err() != nil { diff --git a/internal/parsers/parsefuncs_test.go b/internal/parsers/parsefuncs_test.go index 99aa1887..76e7b2ac 100644 --- a/internal/parsers/parsefuncs_test.go +++ b/internal/parsers/parsefuncs_test.go @@ -15,14 +15,14 @@ import ( ) func TestUnmarshalObj(t *testing.T) { - expected := map[string]interface{}{ - "foo": map[string]interface{}{"bar": "baz"}, + expected := map[string]any{ + "foo": map[string]any{"bar": "baz"}, "one": 1.0, "true": true, "escaped": "\"/\\\b\f\n\r\t∞", } - test := func(actual map[string]interface{}, err error) { + test := func(actual map[string]any, err error) { t.Helper() require.NoError(t, err) assert.Equal(t, expected["foo"], actual["foo"], "foo") @@ -56,24 +56,24 @@ one: 1.0 escaped: "\"\/\\\b\f\n\r\t\u221e" `)) - obj := make(map[string]interface{}) - _, err := unmarshalObj(obj, "SOMETHING", func(_ []byte, _ interface{}) error { + obj := make(map[string]any) + _, err := unmarshalObj(obj, "SOMETHING", func(_ []byte, _ any) error { return fmt.Errorf("fail") }) assert.EqualError(t, err, "unable to unmarshal object SOMETHING: fail") } func TestUnmarshalArray(t *testing.T) { - expected := []interface{}{ + expected := []any{ "foo", "bar", - map[string]interface{}{ - "baz": map[string]interface{}{"qux": true}, - "quux": map[string]interface{}{"42": 18}, - "corge": map[string]interface{}{"false": "blah"}, + map[string]any{ + "baz": map[string]any{"qux": true}, + "quux": map[string]any{"42": 18}, + "corge": map[string]any{"false": "blah"}, }, } - test := func(actual []interface{}, err error) { + test := func(actual []any, err error) { require.NoError(t, err) assert.EqualValues(t, expected, actual) } @@ -116,20 +116,20 @@ this shouldn't be reached `) require.NoError(t, err) assert.EqualValues(t, - []interface{}{ - map[string]interface{}{ - "foo": map[string]interface{}{ + []any{ + map[string]any{ + "foo": map[string]any{ "bar": "baz", }, }, - map[string]interface{}{ - "qux": map[string]interface{}{ + map[string]any{ + "qux": map[string]any{ "bar": "baz", "quux": "corge", }, }, - map[string]interface{}{ - "baz": map[string]interface{}{ + map[string]any{ + "baz": map[string]any{ "qux": true, "42": 18, "false": "blah", @@ -138,8 +138,8 @@ this shouldn't be reached }, actual) - obj := make([]interface{}, 1) - _, err = unmarshalArray(obj, "SOMETHING", func(_ []byte, _ interface{}) error { + obj := make([]any, 1) + _, err = unmarshalArray(obj, "SOMETHING", func(_ []byte, _ any) error { return fmt.Errorf("fail") }) assert.EqualError(t, err, "unable to unmarshal array SOMETHING: fail") @@ -147,12 +147,12 @@ this shouldn't be reached func TestMarshalObj(t *testing.T) { expected := "foo" - actual, err := marshalObj(nil, func(_ interface{}) ([]byte, error) { + actual, err := marshalObj(nil, func(_ any) ([]byte, error) { return []byte("foo"), nil }) require.NoError(t, err) assert.Equal(t, expected, actual) - _, err = marshalObj(nil, func(_ interface{}) ([]byte, error) { + _, err = marshalObj(nil, func(_ any) ([]byte, error) { return nil, fmt.Errorf("fail") }) require.Error(t, err) @@ -179,13 +179,13 @@ func (b *badObject) CodecDecodeSelf(_ *codec.Decoder) { func TestToJSON(t *testing.T) { expected := `{"down":{"the":{"rabbit":{"hole":true}}},"foo":"bar","one":1,"true":true}` - in := map[string]interface{}{ + in := map[string]any{ "foo": "bar", "one": 1, "true": true, - "down": map[interface{}]interface{}{ - "the": map[interface{}]interface{}{ - "rabbit": map[interface{}]interface{}{ + "down": map[any]any{ + "the": map[any]any{ + "rabbit": map[any]any{ "hole": true, }, }, @@ -212,13 +212,13 @@ func TestToJSONPretty(t *testing.T) { "one": 1, "true": true }` - in := map[string]interface{}{ + in := map[string]any{ "foo": "bar", "one": 1, "true": true, - "down": map[string]interface{}{ - "the": map[string]interface{}{ - "rabbit": map[string]interface{}{ + "down": map[string]any{ + "the": map[string]any{ + "rabbit": map[string]any{ "hole": true, }, }, @@ -244,13 +244,13 @@ one: 1 "true": true ` mst, _ := time.LoadLocation("MST") - in := map[string]interface{}{ + in := map[string]any{ "foo": "bar", "one": 1, "true": true, `multi line -key`: map[string]interface{}{ +key`: map[string]any{ "hello": "world", }, "d": time.Date(2006, time.January, 2, 15, 4, 5, 999999999, mst), @@ -384,7 +384,7 @@ func TestToCSV(t *testing.T) { require.Error(t, err) expected = "first,second,third\r\n1,2,3\r\n4,5,6\r\n" - out, err = ToCSV([][]interface{}{ + out, err = ToCSV([][]any{ {"first", "second", "third"}, {"1", "2", "3"}, {"4", "5", "6"}, @@ -393,10 +393,10 @@ func TestToCSV(t *testing.T) { assert.Equal(t, expected, out) expected = "first|second|third\r\n1|2|3\r\n4|5|6\r\n" - out, err = ToCSV("|", []interface{}{ - []interface{}{"first", "second", "third"}, - []interface{}{1, "2", 3}, - []interface{}{"4", 5, "6"}, + out, err = ToCSV("|", []any{ + []any{"first", "second", "third"}, + []any{1, "2", 3}, + []any{"4", 5, "6"}, }) require.NoError(t, err) assert.Equal(t, expected, out) @@ -439,36 +439,36 @@ hosts = [ "omega" ] ` - expected := map[string]interface{}{ + expected := map[string]any{ "title": "TOML Example", - "owner": map[string]interface{}{ + "owner": map[string]any{ "name": "Tom Preston-Werner", "organization": "GitHub", "bio": "GitHub Cofounder & CEO\nLikes tater tots and beer.", "dob": time.Date(1979, time.May, 27, 7, 32, 0, 0, time.UTC), }, - "database": map[string]interface{}{ + "database": map[string]any{ "server": "192.168.1.1", - "ports": []interface{}{int64(8001), int64(8001), int64(8002)}, + "ports": []any{int64(8001), int64(8001), int64(8002)}, "connection_max": int64(5000), "enabled": true, }, - "servers": map[string]interface{}{ - "alpha": map[string]interface{}{ + "servers": map[string]any{ + "alpha": map[string]any{ "ip": "10.0.0.1", "dc": "eqdc10", }, - "beta": map[string]interface{}{ + "beta": map[string]any{ "ip": "10.0.0.2", "dc": "eqdc10", }, }, - "clients": map[string]interface{}{ - "data": []interface{}{ - []interface{}{"gamma", "delta"}, - []interface{}{int64(1), int64(2)}, + "clients": map[string]any{ + "data": []any{ + []any{"gamma", "delta"}, + []any{int64(1), int64(2)}, }, - "hosts": []interface{}{"alpha", "omega"}, + "hosts": []any{"alpha", "omega"}, }, } @@ -487,13 +487,13 @@ true = true [down.the.rabbit] hole = true ` - in := map[string]interface{}{ + in := map[string]any{ "foo": "bar", "one": 1, "true": true, - "down": map[interface{}]interface{}{ - "the": map[interface{}]interface{}{ - "rabbit": map[interface{}]interface{}{ + "down": map[any]any{ + "the": map[any]any{ + "rabbit": map[any]any{ "hole": true, }, }, @@ -507,7 +507,7 @@ true = true func TestDecryptEJSON(t *testing.T) { privateKey := "e282d979654f88267f7e6c2d8268f1f4314b8673579205ed0029b76de9c8223f" publicKey := "6e05ec625bcdca34864181cc43e6fcc20a57732a453bc2f4a2e117ffdf1a6762" - expected := map[string]interface{}{ + expected := map[string]any{ "password": "supersecret", "_unencrypted": "notsosecret", } @@ -555,7 +555,7 @@ FOO.BAR = "values can be double-quoted, and shell\nescapes are supported" BAZ = "variable expansion: ${FOO}" QUX='single quotes ignore $variables' ` - expected := map[string]interface{}{ + expected := map[string]any{ "FOO": "a regular unquoted value", "BAR": "another value, exports are ignored", "FOO.BAR": "values can be double-quoted, and shell\nescapes are supported", @@ -569,43 +569,43 @@ QUX='single quotes ignore $variables' func TestStringifyYAMLArrayMapKeys(t *testing.T) { cases := []struct { - input []interface{} - want []interface{} + input []any + want []any replaced bool }{ { - []interface{}{map[interface{}]interface{}{"a": 1, "b": 2}}, - []interface{}{map[string]interface{}{"a": 1, "b": 2}}, + []any{map[any]any{"a": 1, "b": 2}}, + []any{map[string]any{"a": 1, "b": 2}}, false, }, { - []interface{}{map[interface{}]interface{}{"a": []interface{}{1, map[interface{}]interface{}{"b": 2}}}}, - []interface{}{map[string]interface{}{"a": []interface{}{1, map[string]interface{}{"b": 2}}}}, + []any{map[any]any{"a": []any{1, map[any]any{"b": 2}}}}, + []any{map[string]any{"a": []any{1, map[string]any{"b": 2}}}}, false, }, { - []interface{}{map[interface{}]interface{}{true: 1, "b": false}}, - []interface{}{map[string]interface{}{"true": 1, "b": false}}, + []any{map[any]any{true: 1, "b": false}}, + []any{map[string]any{"true": 1, "b": false}}, false, }, { - []interface{}{map[interface{}]interface{}{1: "a", 2: "b"}}, - []interface{}{map[string]interface{}{"1": "a", "2": "b"}}, + []any{map[any]any{1: "a", 2: "b"}}, + []any{map[string]any{"1": "a", "2": "b"}}, false, }, { - []interface{}{map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": 1}}}, - []interface{}{map[string]interface{}{"a": map[string]interface{}{"b": 1}}}, + []any{map[any]any{"a": map[any]any{"b": 1}}}, + []any{map[string]any{"a": map[string]any{"b": 1}}}, false, }, { - []interface{}{map[string]interface{}{"a": map[string]interface{}{"b": 1}}}, - []interface{}{map[string]interface{}{"a": map[string]interface{}{"b": 1}}}, + []any{map[string]any{"a": map[string]any{"b": 1}}}, + []any{map[string]any{"a": map[string]any{"b": 1}}}, false, }, { - []interface{}{map[interface{}]interface{}{1: "a", 2: "b"}}, - []interface{}{map[string]interface{}{"1": "a", "2": "b"}}, + []any{map[any]any{1: "a", 2: "b"}}, + []any{map[string]any{"1": "a", "2": "b"}}, false, }, } @@ -619,36 +619,36 @@ func TestStringifyYAMLArrayMapKeys(t *testing.T) { func TestStringifyYAMLMapMapKeys(t *testing.T) { cases := []struct { - input map[string]interface{} - want map[string]interface{} + input map[string]any + want map[string]any }{ { - map[string]interface{}{"root": map[interface{}]interface{}{"a": 1, "b": 2}}, - map[string]interface{}{"root": map[string]interface{}{"a": 1, "b": 2}}, + map[string]any{"root": map[any]any{"a": 1, "b": 2}}, + map[string]any{"root": map[string]any{"a": 1, "b": 2}}, }, { - map[string]interface{}{"root": map[interface{}]interface{}{"a": []interface{}{1, map[interface{}]interface{}{"b": 2}}}}, - map[string]interface{}{"root": map[string]interface{}{"a": []interface{}{1, map[string]interface{}{"b": 2}}}}, + map[string]any{"root": map[any]any{"a": []any{1, map[any]any{"b": 2}}}}, + map[string]any{"root": map[string]any{"a": []any{1, map[string]any{"b": 2}}}}, }, { - map[string]interface{}{"root": map[interface{}]interface{}{true: 1, "b": false}}, - map[string]interface{}{"root": map[string]interface{}{"true": 1, "b": false}}, + map[string]any{"root": map[any]any{true: 1, "b": false}}, + map[string]any{"root": map[string]any{"true": 1, "b": false}}, }, { - map[string]interface{}{"root": map[interface{}]interface{}{1: "a", 2: "b"}}, - map[string]interface{}{"root": map[string]interface{}{"1": "a", "2": "b"}}, + map[string]any{"root": map[any]any{1: "a", 2: "b"}}, + map[string]any{"root": map[string]any{"1": "a", "2": "b"}}, }, { - map[string]interface{}{"root": map[interface{}]interface{}{"a": map[interface{}]interface{}{"b": 1}}}, - map[string]interface{}{"root": map[string]interface{}{"a": map[string]interface{}{"b": 1}}}, + map[string]any{"root": map[any]any{"a": map[any]any{"b": 1}}}, + map[string]any{"root": map[string]any{"a": map[string]any{"b": 1}}}, }, { - map[string]interface{}{"a": map[string]interface{}{"b": 1}}, - map[string]interface{}{"a": map[string]interface{}{"b": 1}}, + map[string]any{"a": map[string]any{"b": 1}}, + map[string]any{"a": map[string]any{"b": 1}}, }, { - map[string]interface{}{"root": []interface{}{map[interface{}]interface{}{1: "a", 2: "b"}}}, - map[string]interface{}{"root": []interface{}{map[string]interface{}{"1": "a", "2": "b"}}}, + map[string]any{"root": []any{map[any]any{1: "a", 2: "b"}}}, + map[string]any{"root": []any{map[string]any{"1": "a", "2": "b"}}}, }, } @@ -670,8 +670,8 @@ two: 2 list: [ 1, 2, 3 ] ` - expected := map[string]interface{}{ - "matches": []interface{}{ + expected := map[string]any{ + "matches": []any{ "localhost:443", "localhost", "443", @@ -679,7 +679,7 @@ list: [ 1, 2, 3 ] "one": int64(1), "two": int64(2), "two-and-a-half": 2.5, - "list": []interface{}{int64(1), int64(2), int64(3)}, + "list": []any{int64(1), int64(2), int64(3)}, } out, err := CUE(in) @@ -688,7 +688,7 @@ list: [ 1, 2, 3 ] out, err = CUE(`[1,2,3]`) require.NoError(t, err) - assert.Equal(t, []interface{}{int64(1), int64(2), int64(3)}, out) + assert.Equal(t, []any{int64(1), int64(2), int64(3)}, out) out, err = CUE(`"hello world"`) require.NoError(t, err) @@ -720,8 +720,8 @@ list: [ 1, 2, 3 ] } func TestToCUE(t *testing.T) { - in := map[string]interface{}{ - "matches": []interface{}{ + in := map[string]any{ + "matches": []any{ "localhost:443", "localhost", "443", @@ -729,7 +729,7 @@ func TestToCUE(t *testing.T) { "one": 1, "two": 2, "two-and-a-half": 2.5, - "list": []interface{}{1, 2, 3}, + "list": []any{1, 2, 3}, } expected := `{ @@ -744,7 +744,7 @@ func TestToCUE(t *testing.T) { require.NoError(t, err) assert.EqualValues(t, expected, out) - out, err = ToCUE([]interface{}{1, 2, 3}) + out, err = ToCUE([]any{1, 2, 3}) require.NoError(t, err) assert.EqualValues(t, `[1, 2, 3]`, out) diff --git a/internal/tests/integration/datasources_consul_test.go b/internal/tests/integration/datasources_consul_test.go index 741f91df..dc8f4d80 100644 --- a/internal/tests/integration/datasources_consul_test.go +++ b/internal/tests/integration/datasources_consul_test.go @@ -171,11 +171,11 @@ func TestDatasources_Consul_WithVaultAuth(t *testing.T) { require.NoError(t, err) defer v.vc.Sys().Unmount("consul/") - _, err = v.vc.Logical().Write("consul/config/access", map[string]interface{}{ + _, err = v.vc.Logical().Write("consul/config/access", map[string]any{ "address": consulAddr, "token": consulRootToken, }) require.NoError(t, err) - _, err = v.vc.Logical().Write("consul/roles/readonly", map[string]interface{}{ + _, err = v.vc.Logical().Write("consul/roles/readonly", map[string]any{ "policies": "readonly", }) require.NoError(t, err) diff --git a/internal/tests/integration/datasources_vault_ec2_test.go b/internal/tests/integration/datasources_vault_ec2_test.go index 4b57020d..382d0d4e 100644 --- a/internal/tests/integration/datasources_vault_ec2_test.go +++ b/internal/tests/integration/datasources_vault_ec2_test.go @@ -13,14 +13,14 @@ func TestDatasources_VaultEc2(t *testing.T) { accountID, user := "1", "Test" tmpDir, v, srv, cert := setupDatasourcesVaultAWSTest(t, accountID, user) - v.vc.Logical().Write("secret/foo", map[string]interface{}{"value": "bar"}) + v.vc.Logical().Write("secret/foo", map[string]any{"value": "bar"}) defer v.vc.Logical().Delete("secret/foo") err := v.vc.Sys().EnableAuth("aws", "aws", "") require.NoError(t, err) defer v.vc.Sys().DisableAuth("aws") - _, err = v.vc.Logical().Write("auth/aws/config/client", map[string]interface{}{ + _, err = v.vc.Logical().Write("auth/aws/config/client", map[string]any{ "secret_key": "secret", "access_key": "access", "endpoint": srv.URL + "/ec2", "iam_endpoint": srv.URL + "/iam", @@ -29,12 +29,12 @@ func TestDatasources_VaultEc2(t *testing.T) { }) require.NoError(t, err) - _, err = v.vc.Logical().Write("auth/aws/config/certificate/testcert", map[string]interface{}{ + _, err = v.vc.Logical().Write("auth/aws/config/certificate/testcert", map[string]any{ "type": "pkcs7", "aws_public_cert": string(cert), }) require.NoError(t, err) - _, err = v.vc.Logical().Write("auth/aws/role/ami-00000000", map[string]interface{}{ + _, err = v.vc.Logical().Write("auth/aws/role/ami-00000000", map[string]any{ "auth_type": "ec2", "bound_ami_id": "ami-00000000", "policies": "readpol", }) diff --git a/internal/tests/integration/datasources_vault_iam_test.go b/internal/tests/integration/datasources_vault_iam_test.go index 0cee8d3d..df776636 100644 --- a/internal/tests/integration/datasources_vault_iam_test.go +++ b/internal/tests/integration/datasources_vault_iam_test.go @@ -15,7 +15,7 @@ func TestDatasources_VaultIAM(t *testing.T) { tmpDir, v, srv, _ := setupDatasourcesVaultAWSTest(t, accountID, user) - v.vc.Logical().Write("secret/foo", map[string]interface{}{"value": "bar"}) + v.vc.Logical().Write("secret/foo", map[string]any{"value": "bar"}) defer v.vc.Logical().Delete("secret/foo") err := v.vc.Sys().EnableAuth("aws", "aws", "") @@ -27,7 +27,7 @@ func TestDatasources_VaultIAM(t *testing.T) { accessKeyID := "secret" secretAccessKey := "access" - _, err = v.vc.Logical().Write("auth/aws/config/client", map[string]interface{}{ + _, err = v.vc.Logical().Write("auth/aws/config/client", map[string]any{ "access_key": accessKeyID, "secret_key": secretAccessKey, "endpoint": endpoint, @@ -37,7 +37,7 @@ func TestDatasources_VaultIAM(t *testing.T) { }) require.NoError(t, err) - _, err = v.vc.Logical().Write("auth/aws/role/foo", map[string]interface{}{ + _, err = v.vc.Logical().Write("auth/aws/role/foo", map[string]any{ "auth_type": "iam", "bound_iam_principal_arn": "arn:aws:iam::" + accountID + ":*", "policies": "readpol", diff --git a/internal/tests/integration/datasources_vault_test.go b/internal/tests/integration/datasources_vault_test.go index 74a2512b..a3993dc1 100644 --- a/internal/tests/integration/datasources_vault_test.go +++ b/internal/tests/integration/datasources_vault_test.go @@ -109,7 +109,7 @@ func startVault(t *testing.T) (*fs.Dir, *vaultClient) { func TestDatasources_Vault_TokenAuth(t *testing.T) { v := setupDatasourcesVaultTest(t) - v.vc.Logical().Write("secret/foo", map[string]interface{}{"value": "bar"}) + v.vc.Logical().Write("secret/foo", map[string]any{"value": "bar"}) defer v.vc.Logical().Delete("secret/foo") tok, err := v.tokenCreate("readpol", 5) require.NoError(t, err) @@ -150,7 +150,7 @@ func TestDatasources_Vault_TokenAuth(t *testing.T) { func TestDatasources_Vault_UserPassAuth(t *testing.T) { v := setupDatasourcesVaultTest(t) - v.vc.Logical().Write("secret/foo", map[string]interface{}{"value": "bar"}) + v.vc.Logical().Write("secret/foo", map[string]any{"value": "bar"}) defer v.vc.Logical().Delete("secret/foo") err := v.vc.Sys().EnableAuth("userpass", "userpass", "") require.NoError(t, err) @@ -158,11 +158,11 @@ func TestDatasources_Vault_UserPassAuth(t *testing.T) { require.NoError(t, err) defer v.vc.Sys().DisableAuth("userpass") defer v.vc.Sys().DisableAuth("userpass2") - _, err = v.vc.Logical().Write("auth/userpass/users/dave", map[string]interface{}{ + _, err = v.vc.Logical().Write("auth/userpass/users/dave", map[string]any{ "password": "foo", "ttl": "10s", "policies": "readpol", }) require.NoError(t, err) - _, err = v.vc.Logical().Write("auth/userpass2/users/dave", map[string]interface{}{ + _, err = v.vc.Logical().Write("auth/userpass2/users/dave", map[string]any{ "password": "bar", "ttl": "10s", "policies": "readpol", }) require.NoError(t, err) @@ -202,7 +202,7 @@ func TestDatasources_Vault_UserPassAuth(t *testing.T) { func TestDatasources_Vault_AppRoleAuth(t *testing.T) { v := setupDatasourcesVaultTest(t) - v.vc.Logical().Write("secret/foo", map[string]interface{}{"value": "bar"}) + v.vc.Logical().Write("secret/foo", map[string]any{"value": "bar"}) defer v.vc.Logical().Delete("secret/foo") err := v.vc.Sys().EnableAuth("approle", "approle", "") require.NoError(t, err) @@ -210,12 +210,12 @@ func TestDatasources_Vault_AppRoleAuth(t *testing.T) { require.NoError(t, err) defer v.vc.Sys().DisableAuth("approle") defer v.vc.Sys().DisableAuth("approle2") - _, err = v.vc.Logical().Write("auth/approle/role/testrole", map[string]interface{}{ + _, err = v.vc.Logical().Write("auth/approle/role/testrole", map[string]any{ "secret_id_ttl": "10s", "token_ttl": "20s", "secret_id_num_uses": "1", "policies": "readpol", }) require.NoError(t, err) - _, err = v.vc.Logical().Write("auth/approle2/role/testrole", map[string]interface{}{ + _, err = v.vc.Logical().Write("auth/approle2/role/testrole", map[string]any{ "secret_id_ttl": "10s", "token_ttl": "20s", "secret_id_num_uses": "1", "policies": "readpol", }) @@ -256,7 +256,7 @@ func TestDatasources_Vault_DynamicAuth(t *testing.T) { require.NoError(t, err) defer v.vc.Sys().Unmount("ssh") - _, err = v.vc.Logical().Write("ssh/roles/test", map[string]interface{}{ + _, err = v.vc.Logical().Write("ssh/roles/test", map[string]any{ "key_type": "otp", "default_user": "user", "cidr_list": "10.0.0.0/8", }) require.NoError(t, err) @@ -284,8 +284,8 @@ func TestDatasources_Vault_DynamicAuth(t *testing.T) { func TestDatasources_Vault_List(t *testing.T) { v := setupDatasourcesVaultTest(t) - v.vc.Logical().Write("secret/dir/foo", map[string]interface{}{"value": "one"}) - v.vc.Logical().Write("secret/dir/bar", map[string]interface{}{"value": "two"}) + v.vc.Logical().Write("secret/dir/foo", map[string]any{"value": "one"}) + v.vc.Logical().Write("secret/dir/bar", map[string]any{"value": "two"}) defer v.vc.Logical().Delete("secret/dir/foo") defer v.vc.Logical().Delete("secret/dir/bar") tok, err := v.tokenCreate("listpol", 15) @@ -322,15 +322,15 @@ func setupKV2Test(ctx context.Context, t *testing.T, policy string) (string, str }) require.NoError(t, err) - s, err := v.vc.KVv2("kv2").Put(ctx, "foo", map[string]interface{}{"first": "one"}, vaultapi.WithCheckAndSet(0)) + s, err := v.vc.KVv2("kv2").Put(ctx, "foo", map[string]any{"first": "one"}, vaultapi.WithCheckAndSet(0)) require.NoError(t, err) require.Equal(t, 1, s.VersionMetadata.Version) - s, err = v.vc.KVv2("kv2").Put(ctx, "foo", map[string]interface{}{"second": "two"}, vaultapi.WithCheckAndSet(1)) + s, err = v.vc.KVv2("kv2").Put(ctx, "foo", map[string]any{"second": "two"}, vaultapi.WithCheckAndSet(1)) require.NoError(t, err) require.Equal(t, 2, s.VersionMetadata.Version) - s, err = v.vc.KVv2("a/b/c").Put(ctx, "d/e/f", map[string]interface{}{"e": "f"}) + s, err = v.vc.KVv2("a/b/c").Put(ctx, "d/e/f", map[string]any{"e": "f"}) require.NoError(t, err) require.Equal(t, 1, s.VersionMetadata.Version) diff --git a/internal/tests/integration/inputdir_unix_test.go b/internal/tests/integration/inputdir_unix_test.go index 7080f552..9fae6994 100644 --- a/internal/tests/integration/inputdir_unix_test.go +++ b/internal/tests/integration/inputdir_unix_test.go @@ -35,7 +35,7 @@ func checkFileUlimit(t *testing.T, b uint64) { func TestInputDir_RespectsUlimit(t *testing.T) { numfiles := uint32(32) flist := map[string]string{} - for i := 0; i < int(numfiles); i++ { + for i := range int(numfiles) { k := fmt.Sprintf("file_%d", i) flist[k] = fmt.Sprintf("hello world %d\n", i) } @@ -67,7 +67,7 @@ func TestInputDir_RespectsUlimit(t *testing.T) { assert.NilError(t, err) assert.Equal(t, int(numfiles), len(files)) - for i := 0; i < int(numfiles); i++ { + for i := range int(numfiles) { f := testdir.Join("out", fmt.Sprintf("file_%d", i)) _, err := os.Stat(f) assert.NilError(t, err) diff --git a/internal/tests/integration/test_ec2_utils_test.go b/internal/tests/integration/test_ec2_utils_test.go index 29b92350..9792021d 100644 --- a/internal/tests/integration/test_ec2_utils_test.go +++ b/internal/tests/integration/test_ec2_utils_test.go @@ -129,7 +129,7 @@ func stsHandler(t *testing.T, accountID, user string) http.Handler { assert.Equal(t, "GetCallerIdentity", form.Get("Action")) w.Header().Set("Content-Type", "text/xml") - _, err := w.Write([]byte(fmt.Sprintf(`<?xml version='1.0' encoding='utf-8'?> + _, err := w.Write(fmt.Appendf(nil, `<?xml version='1.0' encoding='utf-8'?> <GetCallerIdentityResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/"> <GetCallerIdentityResult> <Arn>arn:aws:iam::%[1]s:user/%[2]s</Arn> @@ -139,7 +139,7 @@ func stsHandler(t *testing.T, accountID, user string) http.Handler { <ResponseMetadata> <RequestId>01234567-89ab-cdef-0123-456789abcdef</RequestId> </ResponseMetadata> - </GetCallerIdentityResponse>`, accountID, user))) + </GetCallerIdentityResponse>`, accountID, user)) if err != nil { t.Errorf("failed to write response: %s", err) w.WriteHeader(http.StatusInternalServerError) @@ -284,7 +284,7 @@ func iamGetUserHandler(t *testing.T, accountID string) http.Handler { assert.Equal(t, "GetUser", form.Get("Action")) w.Header().Set("Content-Type", "text/xml") - _, err := w.Write([]byte(fmt.Sprintf(`<?xml version='1.0' encoding='utf-8'?> + _, err := w.Write(fmt.Appendf(nil, `<?xml version='1.0' encoding='utf-8'?> <GetUserResponse xmlns="https://iam.amazonaws.com/doc/2010-05-08/"> <GetUserResult> <User> @@ -298,7 +298,7 @@ func iamGetUserHandler(t *testing.T, accountID string) http.Handler { <ResponseMetadata> <RequestId>3d0e2445-64ea-4bfb-9244-30d810773f9e</RequestId> </ResponseMetadata> - </GetUserResponse>`, form.Get("UserName"), accountID))) + </GetUserResponse>`, form.Get("UserName"), accountID)) if err != nil { w.WriteHeader(http.StatusInternalServerError) } |