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/funcs | |
| 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/funcs')
43 files changed, 434 insertions, 442 deletions
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", |