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>

5 files changed, 20 insertions, 20 deletions

diff --git a/internal/datafs/envfs.go b/internal/datafs/envfs.go
index 0a8d82c4..6418fcd9 100644
--- a/internal/datafs/envfs.go
+++ b/internal/datafs/envfs.go
@@ -194,7 +194,7 @@ func (fi staticFileInfo) Mode() fs.FileMode           { return fi.mode }
 func (fi *staticFileInfo) ModTime() time.Time         { return fi.modTime }
 func (fi staticFileInfo) Name() string                { return fi.name }
 func (fi staticFileInfo) Size() int64                 { return fi.size }
-func (fi staticFileInfo) Sys() interface{}            { return nil }
+func (fi staticFileInfo) Sys() any                    { return nil }
 func (fi *staticFileInfo) Info() (fs.FileInfo, error) { return fi, nil }
 func (fi staticFileInfo) Type() fs.FileMode           { return fi.Mode().Type() }
 
diff --git a/internal/datafs/mergefs.go b/internal/datafs/mergefs.go
index 1559b5fb..4c10fb1d 100644
--- a/internal/datafs/mergefs.go
+++ b/internal/datafs/mergefs.go
@@ -264,7 +264,7 @@ func (f *mergeFile) readSubFile(sf subFile) (map[string]any, error) {
 	return sfData, nil
 }
 
-func mergeData(data []map[string]interface{}) ([]byte, error) {
+func mergeData(data []map[string]any) ([]byte, error) {
 	dst := data[0]
 	data = data[1:]
 
diff --git a/internal/datafs/mergefs_test.go b/internal/datafs/mergefs_test.go
index 012c5a95..d03c63d5 100644
--- a/internal/datafs/mergefs_test.go
+++ b/internal/datafs/mergefs_test.go
@@ -97,59 +97,59 @@ func wdForTest(t *testing.T) string {
 }
 
 func TestMergeData(t *testing.T) {
-	def := map[string]interface{}{
+	def := map[string]any{
 		"f": true,
 		"t": false,
 		"z": "def",
 	}
-	out, err := mergeData([]map[string]interface{}{def})
+	out, err := mergeData([]map[string]any{def})
 	require.NoError(t, err)
 	assert.Equal(t, "f: true\nt: false\nz: def\n", string(out))
 
-	over := map[string]interface{}{
+	over := map[string]any{
 		"f": false,
 		"t": true,
 		"z": "over",
 	}
-	out, err = mergeData([]map[string]interface{}{over, def})
+	out, err = mergeData([]map[string]any{over, def})
 	require.NoError(t, err)
 	assert.Equal(t, "f: false\nt: true\nz: over\n", string(out))
 
-	over = map[string]interface{}{
+	over = map[string]any{
 		"f": false,
 		"t": true,
 		"z": "over",
-		"m": map[string]interface{}{
+		"m": map[string]any{
 			"a": "aaa",
 		},
 	}
-	out, err = mergeData([]map[string]interface{}{over, def})
+	out, err = mergeData([]map[string]any{over, def})
 	require.NoError(t, err)
 	assert.Equal(t, "f: false\nm:\n  a: aaa\nt: true\nz: over\n", string(out))
 
-	uber := map[string]interface{}{
+	uber := map[string]any{
 		"z": "über",
 	}
-	out, err = mergeData([]map[string]interface{}{uber, over, def})
+	out, err = mergeData([]map[string]any{uber, over, def})
 	require.NoError(t, err)
 	assert.Equal(t, "f: false\nm:\n  a: aaa\nt: true\nz: über\n", string(out))
 
-	uber = map[string]interface{}{
+	uber = map[string]any{
 		"m": "notamap",
-		"z": map[string]interface{}{
+		"z": map[string]any{
 			"b": "bbb",
 		},
 	}
-	out, err = mergeData([]map[string]interface{}{uber, over, def})
+	out, err = mergeData([]map[string]any{uber, over, def})
 	require.NoError(t, err)
 	assert.Equal(t, "f: false\nm: notamap\nt: true\nz:\n  b: bbb\n", string(out))
 
-	uber = map[string]interface{}{
-		"m": map[string]interface{}{
+	uber = map[string]any{
+		"m": map[string]any{
 			"b": "bbb",
 		},
 	}
-	out, err = mergeData([]map[string]interface{}{uber, over, def})
+	out, err = mergeData([]map[string]any{uber, over, def})
 	require.NoError(t, err)
 	assert.Equal(t, "f: false\nm:\n  a: aaa\n  b: bbb\nt: true\nz: over\n", string(out))
 }
diff --git a/internal/datafs/reader_test.go b/internal/datafs/reader_test.go
index 740cfa53..dbb37edc 100644
--- a/internal/datafs/reader_test.go
+++ b/internal/datafs/reader_test.go
@@ -127,7 +127,7 @@ func BenchmarkResolveURL(b *testing.B) {
 
 	for _, a := range args {
 		b.Run(fmt.Sprintf("base=%s_rel=%s", &a.url, a.rel), func(b *testing.B) {
-			for i := 0; i < b.N; i++ {
+			for b.Loop() {
 				_, _ = resolveURL(a.url, a.rel)
 			}
 		})
diff --git a/internal/datafs/stdinfs_test.go b/internal/datafs/stdinfs_test.go
index 8b0e0598..ba14483f 100644
--- a/internal/datafs/stdinfs_test.go
+++ b/internal/datafs/stdinfs_test.go
@@ -104,7 +104,7 @@ func TestStdinFS(t *testing.T) {
 		ctx := ContextWithStdin(context.Background(), bytes.NewReader(content))
 		fsys = fsimpl.WithContextFS(ctx, fsys)
 
-		for i := 0; i < 3; i++ {
+		for i := range 3 {
 			f, err := fsys.Open("foo")
 			require.NoError(t, err)
 
@@ -118,7 +118,7 @@ func TestStdinFS(t *testing.T) {
 		ctx := ContextWithStdin(context.Background(), bytes.NewReader(content))
 		fsys = fsimpl.WithContextFS(ctx, fsys)
 
-		for i := 0; i < 3; i++ {
+		for i := range 3 {
 			b, err := fs.ReadFile(fsys, "foo")
 			require.NoError(t, err)
 			require.Equal(t, content, b, "read %d failed", i)