feat: replace interface{} with any (#136)

Signed-off-by: Manuel Alonso <[email protected]>

Author: manute

config/decode.go

@@ -44,7 +44,7 @@ type StringDecoder interface {
 //
 // Most of the heavy lifting is handled by the mapstructure library. A custom decoder is used to handle
 // decoding string values to the supported primitives.
-func Decode(input interface{}, output interface{}) error {
+func Decode(input any, output any) error {
 	decoder, err := mapstructure.NewDecoder(
 		&mapstructure.DecoderConfig{ //nolint: exhaustruct
 			Result:     output,

config/decode_test.go

@@ -92,8 +92,8 @@ func (u *Decoded) DecodeString(text string) error {
 
 func TestDecode(t *testing.T) {
 	timeVal := getTimeVal()
-	tests := map[string]interface{}{
-		"primitive values": map[string]interface{}{
+	tests := map[string]any{
+		"primitive values": map[string]any{
 			"int":         -9999,
 			"intPtr":      ptr.Of(-9999),
 			"int64":       -1234,
@@ -128,16 +128,16 @@ func TestDecode(t *testing.T) {
 			"stringPtr":   ptr.Of("1234"),
 			"decoded":     "unlimited",
 			"decodedPtr":  "unlimited",
-			"nested": map[string]interface{}{
+			"nested": map[string]any{
 				"integer": 1234,
 				"string":  5678,
 			},
-			"nestedPtr": map[string]interface{}{
+			"nestedPtr": map[string]any{
 				"integer": 1234,
 				"string":  5678,
 			},
 		},
-		"string values": map[string]interface{}{
+		"string values": map[string]any{
 			"int":         "-9999",
 			"intPtr":      "-9999",
 			"int64":       "-1234",
@@ -196,7 +196,7 @@ func TestDecode(t *testing.T) {
 
 func TestDecodeErrors(t *testing.T) {
 	var actual testConfig
-	err := config.Decode(map[string]interface{}{
+	err := config.Decode(map[string]any{
 		"int":         "-badval",
 		"intPtr":      "-badval",
 		"int64":       "-badval",

config/normalize.go

@@ -21,11 +21,11 @@ import (
 // for JSON and usage in component initialization.
 //
 //nolint:cyclop
-func Normalize(i interface{}) (interface{}, error) {
+func Normalize(i any) (any, error) {
 	var err error
 	switch x := i.(type) {
-	case map[interface{}]interface{}:
-		m2 := map[string]interface{}{}
+	case map[any]any:
+		m2 := map[string]any{}
 		for k, v := range x {
 			if strKey, ok := k.(string); ok {
 				if m2[strKey], err = Normalize(v); err != nil {
@@ -37,16 +37,16 @@ func Normalize(i interface{}) (interface{}, error) {
 		}
 
 		return m2, nil
-	case map[string]interface{}:
-		m2 := map[string]interface{}{}
+	case map[string]any:
+		m2 := map[string]any{}
 		for k, v := range x {
 			if m2[k], err = Normalize(v); err != nil {
 				return nil, err
 			}
 		}
 
 		return m2, nil
-	case []interface{}:
+	case []any:
 		for i, v := range x {
 			if x[i], err = Normalize(v); err != nil {
 				return nil, err

config/normalize_test.go

@@ -24,67 +24,67 @@ import (
 
 func TestNormalize(t *testing.T) {
 	tests := map[string]struct {
-		input    interface{}
-		expected interface{}
+		input    any
+		expected any
 		err      string
 	}{
 		"simple": {input: "test", expected: "test"},
 		"map of string to interface{}": {
-			input: map[string]interface{}{
+			input: map[string]any{
 				"test": "1234",
-				"nested": map[string]interface{}{
+				"nested": map[string]any{
 					"value": "5678",
 				},
-			}, expected: map[string]interface{}{
+			}, expected: map[string]any{
 				"test": "1234",
-				"nested": map[string]interface{}{
+				"nested": map[string]any{
 					"value": "5678",
 				},
 			},
 		},
 		"map of string to interface{} with error": {
-			input: map[string]interface{}{
+			input: map[string]any{
 				"test": "1234",
-				"nested": map[interface{}]interface{}{
+				"nested": map[any]any{
 					5678: "5678",
 				},
 			}, err: "error parsing config field: 5678",
 		},
 		"map of interface{} to interface{}": {
-			input: map[string]interface{}{
+			input: map[string]any{
 				"test": "1234",
-				"nested": map[interface{}]interface{}{
+				"nested": map[any]any{
 					"value": "5678",
 				},
-			}, expected: map[string]interface{}{
+			}, expected: map[string]any{
 				"test": "1234",
-				"nested": map[string]interface{}{
+				"nested": map[string]any{
 					"value": "5678",
 				},
 			},
 		},
 		"map of interface{} to interface{} with error": {
-			input: map[interface{}]interface{}{
+			input: map[any]any{
 				"test": "1234",
-				"nested": map[interface{}]interface{}{
+				"nested": map[any]any{
 					5678: "5678",
 				},
 			}, err: "error parsing config field: 5678",
 		},
 		"slice of interface{}": {
-			input: []interface{}{
-				map[interface{}]interface{}{
+			input: []any{
+				map[any]any{
 					"value": "5678",
 				},
-			}, expected: []interface{}{
-				map[string]interface{}{
+			}, expected: []any{
+				map[string]any{
 					"value": "5678",
 				},
 			},
 		},
 		"slice of interface{} with error": {
-			input: []interface{}{
-				map[interface{}]interface{}{
+			input: []any{
+				map[any]any{
 					1234: "1234",
 				},
 			}, err: "error parsing config field: 1234",

config/prefix.go

@@ -18,7 +18,7 @@ import (
 	"unicode"
 )
 
-func PrefixedBy(input interface{}, prefix string) (interface{}, error) {
+func PrefixedBy(input any, prefix string) (any, error) {
 	normalized, err := Normalize(input)
 	if err != nil {
 		// The only error that can come from normalize is if
@@ -28,8 +28,8 @@ func PrefixedBy(input interface{}, prefix string) (interface{}, error) {
 	}
 	input = normalized
 
-	if inputMap, ok := input.(map[string]interface{}); ok {
-		converted := make(map[string]interface{}, len(inputMap))
+	if inputMap, ok := input.(map[string]any); ok {
+		converted := make(map[string]any, len(inputMap))
 		for k, v := range inputMap {
 			if strings.HasPrefix(k, prefix) {
 				key := uncapitalize(strings.TrimPrefix(k, prefix))

config/prefix_test.go

@@ -25,8 +25,8 @@ import (
 func TestPrefixedBy(t *testing.T) {
 	tests := map[string]struct {
 		prefix   string
-		input    interface{}
-		expected interface{}
+		input    any
+		expected any
 		err      string
 	}{
 		"map of string to string": {
@@ -44,13 +44,13 @@ func TestPrefixedBy(t *testing.T) {
 		},
 		"map of string to interface{}": {
 			prefix: "test",
-			input: map[string]interface{}{
+			input: map[string]any{
 				"":        "",
 				"ignore":  "don't include me",
 				"testOne": "include me",
 				"testTwo": "and me",
 			},
-			expected: map[string]interface{}{
+			expected: map[string]any{
 				"one": "include me",
 				"two": "and me",
 			},

cron/logger.go

@@ -18,7 +18,7 @@ You can check the original license at:
 package cron
 
 import (
-	"io/ioutil"
+	"io"
 	"log"
 	"os"
 	"strings"
@@ -29,48 +29,48 @@ import (
 var DefaultLogger Logger = PrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))
 
 // DiscardLogger can be used by callers to discard all log messages.
-var DiscardLogger Logger = PrintfLogger(log.New(ioutil.Discard, "", 0))
+var DiscardLogger Logger = PrintfLogger(log.New(io.Discard, "", 0))
 
 // Logger is the interface used in this package for logging, so that any backend
 // can be plugged in. It is a subset of the github.com/go-logr/logr interface.
 type Logger interface {
 	// Info logs routine messages about cron's operation.
-	Info(msg string, keysAndValues ...interface{})
+	Info(msg string, keysAndValues ...any)
 	// Error logs an error condition.
-	Error(err error, msg string, keysAndValues ...interface{})
+	Error(err error, msg string, keysAndValues ...any)
 }
 
 // PrintfLogger wraps a Printf-based logger (such as the standard library "log")
 // into an implementation of the Logger interface which logs errors only.
-func PrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger {
+func PrintfLogger(l interface{ Printf(string, ...any) }) Logger {
 	return printfLogger{l, false}
 }
 
 // VerbosePrintfLogger wraps a Printf-based logger (such as the standard library
 // "log") into an implementation of the Logger interface which logs everything.
-func VerbosePrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger {
+func VerbosePrintfLogger(l interface{ Printf(string, ...any) }) Logger {
 	return printfLogger{l, true}
 }
 
 type printfLogger struct {
-	logger  interface{ Printf(string, ...interface{}) }
+	logger  interface{ Printf(string, ...any) }
 	logInfo bool
 }
 
-func (pl printfLogger) Info(msg string, keysAndValues ...interface{}) {
+func (pl printfLogger) Info(msg string, keysAndValues ...any) {
 	if pl.logInfo {
 		keysAndValues = formatTimes(keysAndValues)
 		pl.logger.Printf(
 			formatString(len(keysAndValues)),
-			append([]interface{}{msg}, keysAndValues...)...)
+			append([]any{msg}, keysAndValues...)...)
 	}
 }
 
-func (pl printfLogger) Error(err error, msg string, keysAndValues ...interface{}) {
+func (pl printfLogger) Error(err error, msg string, keysAndValues ...any) {
 	keysAndValues = formatTimes(keysAndValues)
 	pl.logger.Printf(
 		formatString(len(keysAndValues)+2),
-		append([]interface{}{msg, "error", err}, keysAndValues...)...)
+		append([]any{msg, "error", err}, keysAndValues...)...)
 }
 
 // formatString returns a logfmt-like format string for the number of
@@ -91,8 +91,8 @@ func formatString(numKeysAndValues int) string {
 }
 
 // formatTimes formats any time.Time values as RFC3339.
-func formatTimes(keysAndValues []interface{}) []interface{} {
-	var formattedArgs []interface{}
+func formatTimes(keysAndValues []any) []any {
+	var formattedArgs []any
 	for _, arg := range keysAndValues {
 		if t, ok := arg.(time.Time); ok {
 			arg = t.Format(time.RFC3339)