Revert "fix: Differenciate between new segments and map keys (#3056)" (#3167)

This reverts commit 2b10464.

Author: johannesfrey

pkg/util/patch/patch.go

@@ -8,7 +8,6 @@ import (
 
 	jsonpatch "github.com/evanphx/json-patch/v5"
 	"github.com/samber/lo"
-	"k8s.io/klog/v2"
 	"sigs.k8s.io/controller-runtime/pkg/client"
 )
 
@@ -57,23 +56,20 @@ func (p Patch) Clear() {
 	}
 }
 
-type translateFn func(path string, val interface{}, exists bool) (interface{}, error)
-
-func (p Patch) MustTranslate(path string, translate translateFn) {
+func (p Patch) MustTranslate(path string, translate func(path string, val interface{}) (interface{}, error)) {
 	err := p.Translate(path, translate)
 	if err != nil {
 		panic(err)
 	}
 }
 
-// Translate changes values on the given path.
-func (p Patch) Translate(path string, translate translateFn) error {
-	parsedPath, err := parsePathWithIndexing(path, true)
+// Translate changes existing (!) values on the given path. If you want to set a value, use the set function instead.
+func (p Patch) Translate(path string, translate func(path string, val interface{}) (interface{}, error)) error {
+	parsedPath, err := parsePath(path)
 	if err != nil {
 		panic(err)
-	}
-	if len(parsedPath) == 0 {
-		retVal, err := translate("", map[string]interface{}(p), true)
+	} else if len(parsedPath) == 0 {
+		retVal, err := translate("", map[string]interface{}(p))
 		if err != nil {
 			return err
 		}
@@ -88,8 +84,8 @@ func (p Patch) Translate(path string, translate translateFn) error {
 
 	// get last map / array
 	curs, ok := p.getValue(parsedPath, 1)
+
 	if !ok {
-		klog.V(0).ErrorS(fmt.Errorf("could not find path %q in patch", path), "not found", "path", path)
 		return nil
 	}
 
@@ -99,10 +95,9 @@ func (p Patch) Translate(path string, translate translateFn) error {
 
 		switch t := cur.Value.(type) {
 		case []interface{}:
-			segment = trimBracketsPair(segment)
 			if segment == "*" {
 				for k := range t {
-					t[k], err = translate(addPathElement(cur.Path, strconv.Itoa(k)), t[k], true)
+					t[k], err = translate(addPathElement(cur.Path, strconv.Itoa(k)), t[k])
 					if err != nil {
 						return err
 					}
@@ -119,44 +114,30 @@ func (p Patch) Translate(path string, translate translateFn) error {
 				return nil
 			}
 
-			ret, err := translate(addPathElement(cur.Path, segment), t[index], true)
+			ret, err := translate(addPathElement(cur.Path, segment), t[index])
 			if err != nil {
 				return err
 			}
 
 			t[index] = ret
 
 		case map[string]interface{}:
-			switch {
-			case segment == "[*]":
+			if segment == "*" {
 				for k := range t {
-					t[k], err = translate(addPathElement(cur.Path, k), t[k], true)
+					t[k], err = translate(addPathElement(cur.Path, k), t[k])
 					if err != nil {
 						return err
 					}
 				}
-			case isBracketEnclosed(segment): // a.path.to.some["segment"] case
-				key := trimBracketsPair(segment)
-				if key == "" {
-					return fmt.Errorf("empty key in bracket notation in path %q", segment)
-				}
-				v, ok := t[key]
-				valueFromExpression, err := translate(cur.Path, v, ok)
-				if err != nil {
-					return fmt.Errorf("translate value for key %q in path %q: %w", key, cur.Path, err)
-				}
-				if valueFromExpression == nil {
-					p.Delete(JoinPath(cur.Path, key))
-					continue
-				}
-				t[key] = valueFromExpression
 
-			default: // a.path.to.some.segment case
-				if val, ok := t[segment]; ok {
-					t[segment], err = translate(JoinPath(cur.Path, segment), val, ok)
-					if err != nil {
-						return err
-					}
+				continue
+			}
+
+			val, ok := t[segment]
+			if ok {
+				t[segment], err = translate(JoinPath(cur.Path, segment), val)
+				if err != nil {
+					return err
 				}
 			}
 		}
@@ -209,8 +190,7 @@ func (p Patch) Delete(path string) {
 
 	// delete last element, we only support maps here for now.
 	for _, cur := range curs {
-		segment := parsedPath[len(parsedPath)-1]
-		if segment == "*" {
+		if parsedPath[len(parsedPath)-1] == "*" {
 			if t, ok := cur.Value.(map[string]interface{}); ok {
 				for k := range t {
 					delete(t, k)
@@ -220,7 +200,7 @@ func (p Patch) Delete(path string) {
 		}
 
 		if t, ok := cur.Value.(map[string]interface{}); ok {
-			delete(t, segment)
+			delete(t, parsedPath[len(parsedPath)-1])
 		}
 	}
 
@@ -389,10 +369,9 @@ func nextValue(parsedPath []string, index int, cur *PathValue, create bool) ([]P
 		return []PathValue{*cur}, true
 	}
 
-	firstPath := trimBracketsPair(parsedPath[0])
 	switch val := cur.Value.(type) {
 	case map[string]interface{}:
-		if firstPath == "*" {
+		if parsedPath[0] == "*" {
 			retVals := make([]PathValue, 0, len(val))
 			for k := range val {
 				retVal, ok := nextValue(parsedPath[1:], index, &PathValue{
@@ -412,23 +391,23 @@ func nextValue(parsedPath []string, index int, cur *PathValue, create bool) ([]P
 			return retVals, true
 		}
 
-		mapValue, ok := val[firstPath]
+		mapValue, ok := val[parsedPath[0]]
 		if !ok && !create {
 			return nil, false
 		} else if create && (!ok || mapValue == nil) {
-			val[firstPath] = createValue(parsedPath[1:])
-			mapValue = val[firstPath]
+			val[parsedPath[0]] = createValue(parsedPath[1:])
+			mapValue = val[parsedPath[0]]
 		}
 
 		return nextValue(parsedPath[1:], index, &PathValue{
 			Parent: cur,
 			Value:  mapValue,
-			Key:    firstPath,
-			Path:   addPathElement(cur.Path, firstPath),
+			Key:    parsedPath[0],
+			Path:   addPathElement(cur.Path, parsedPath[0]),
 		}, create)
 	case []interface{}:
 		// try to match all
-		if firstPath == "*" {
+		if parsedPath[0] == "*" {
 			retVals := make([]PathValue, 0, len(val))
 			for i := range val {
 				retVal, ok := nextValue(parsedPath[1:], index, &PathValue{
@@ -449,7 +428,7 @@ func nextValue(parsedPath []string, index int, cur *PathValue, create bool) ([]P
 		}
 
 		// try to get index
-		indexSegment, err := strconv.Atoi(firstPath)
+		indexSegment, err := strconv.Atoi(parsedPath[0])
 		if err != nil {
 			return nil, false
 		}
@@ -475,7 +454,7 @@ func nextValue(parsedPath []string, index int, cur *PathValue, create bool) ([]P
 			Parent: cur,
 			Value:  arrVal,
 			Index:  indexSegment,
-			Path:   addPathElement(cur.Path, firstPath),
+			Path:   addPathElement(cur.Path, parsedPath[0]),
 		}, create)
 	}
 
@@ -487,8 +466,7 @@ func createValue(pathSegment []string) interface{} {
 		return map[string]interface{}{}
 	}
 
-	segment := trimBracketsPair(pathSegment[0])
-	intVal, err := strconv.Atoi(segment)
+	intVal, err := strconv.Atoi(pathSegment[0])
 	if err == nil {
 		newVal := make([]interface{}, 0, intVal+1)
 		for i := 0; i <= intVal; i++ {
@@ -519,17 +497,3 @@ func JoinPath(root, next string) string {
 	}
 	return root + "." + next
 }
-
-func trimBracketsPair(segment string) string {
-	if isBracketEnclosed(segment) {
-		return segment[1 : len(segment)-1]
-	}
-	return segment
-}
-
-func isBracketEnclosed(segment string) bool {
-	if len(segment) < 2 {
-		return false
-	}
-	return segment[0] == '[' && segment[len(segment)-1] == ']'
-}