Support wildcard replacements and rounding as well

Author: merschformann

golden/map.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"math"
 	"reflect"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -23,17 +24,32 @@ func replaceTransient(
 
 	replaced := map[string]any{}
 	for key, value := range original {
+		// Keep the original value.
 		replaced[key] = value
+
+		// Check if the field is meant to be replaced. If not, continue.
+		// We also check for wildcard replacements that are meant to replace all
+		// fields in a slice.
 		replacement, isTransient := transientLookup[key]
-		if !isTransient {
+		cleanedKey := replaceIndicesInKeys(key)
+		replacementCleaned, isTransientCleaned := transientLookup[cleanedKey]
+		if !isTransient && !isTransientCleaned {
+			// No replacement defined, continue and keep the original value.
 			continue
 		}
+		if isTransientCleaned {
+			replacement = replacementCleaned
+		}
 
+		// Replace the value with the replacement value.
 		if replacement != nil {
 			replaced[key] = replacement
 			continue
 		}
 
+		// No replacement defined, we fall back to default stable values here
+		// (based on type).
+
 		if stringValue, isString := value.(string); isString {
 			if _, err := time.Parse(time.RFC3339, stringValue); err == nil {
 				replaced[key] = StableTime
@@ -82,21 +98,35 @@ func roundFields(
 
 	replaced := map[string]any{}
 	for key, value := range original {
+		// Keep the original value.
 		replaced[key] = value
+
+		// Check if the field is meant to be rounded. If not, continue.
+		// We also check for wildcard replacements that are meant to replace all
+		// fields in a slice.
+		cleanedKey := replaceIndicesInKeys(key)
 		replacement, isRounded := roundingLookup[key]
-		if !isRounded {
+		replacementCleaned, isRoundedCleaned := roundingLookup[cleanedKey]
+		if !isRounded && !isRoundedCleaned {
+			// No rounding defined, continue and keep the original value.
 			continue
 		}
+		if isRoundedCleaned {
+			replacement = replacementCleaned
+		}
 
+		// We don't deal with negative precision values.
 		if replacement < 0 {
 			continue
 		}
 
+		// Replace the value with the rounded value.
 		if _, isFloat := value.(float64); isFloat {
 			replaced[key] = round(value.(float64), replacement)
 			continue
 		}
 
+		// If the value was not a float, return an error.
 		return nil, fmt.Errorf("field %s is not a float", key)
 	}
 
@@ -109,6 +139,14 @@ func round(value float64, precision int) float64 {
 	return math.Round(value*shift) / shift
 }
 
+var keyIndexMatcher = regexp.MustCompile(`\[\d+\]`)
+
+// replaceIndicesInKeys replaces all the indices in a key with "[]" to make it
+// easier to match them with configuration defined in jq-style.
+func replaceIndicesInKeys(key string) string {
+	return keyIndexMatcher.ReplaceAllString(key, "[]")
+}
+
 /*
 flatten takes a nested map and flattens it into a single level map. The
 flattening roughly follows the [JSONPath] standard. Please see test function to