fix lint errors

Author: madhunzv

diff/diff_test.go

@@ -636,8 +636,8 @@ spec:
 	require.Len(t, entry.Changes, 2)
 	replicasChange, ok := findChange(entry.Changes, "spec", "replicas")
 	require.True(t, ok)
-	require.Equal(t, float64(2), replicasChange.OldValue)
-	require.Equal(t, float64(3), replicasChange.NewValue)
+	require.InDelta(t, float64(2), replicasChange.OldValue, 0.001)
+	require.InDelta(t, float64(3), replicasChange.NewValue, 0.001)
 
 	imageChange, ok := findChange(entry.Changes, "spec.template.spec.containers[0]", "image")
 	require.True(t, ok)
@@ -713,7 +713,7 @@ data:
 	require.NoError(t, json.Unmarshal(buf.Bytes(), &entries))
 	require.Len(t, entries, 1)
 	require.True(t, entries[0].ChangesSuppressed)
-	require.Len(t, entries[0].Changes, 0)
+	require.Empty(t, entries[0].Changes)
 }
 
 func findChange(changes []FieldChange, path, field string) (FieldChange, bool) {

diff/structured.go

@@ -1,12 +1,15 @@
 package diff
 
 import (
+	"bytes"
 	"encoding/json"
 	"fmt"
+	"reflect"
+	"sort"
 	"strconv"
 	"strings"
 
-	jsonpatch "gomodules.xyz/jsonpatch/v2"
+	jsonpatch "github.com/evanphx/json-patch/v5"
 	"sigs.k8s.io/yaml"
 
 	"github.com/databus23/helm-diff/v3/manifest"
@@ -151,115 +154,201 @@ func (e *StructuredEntry) populateMetadata(key string, objects ...map[string]int
 }
 
 func calculateFieldChanges(oldJSON, newJSON []byte) ([]FieldChange, error) {
-	patch, err := jsonpatch.CreatePatch(oldJSON, newJSON)
+	patchBytes, err := jsonpatch.CreateMergePatch(oldJSON, newJSON)
 	if err != nil {
 		return nil, err
 	}
-	if len(patch) == 0 {
+	trimmed := bytes.TrimSpace(patchBytes)
+	if len(trimmed) == 0 || bytes.Equal(trimmed, []byte("{}")) {
 		return nil, nil
 	}
 
-	var oldDoc interface{}
-	if err := json.Unmarshal(oldJSON, &oldDoc); err != nil {
+	var patch interface{}
+	if err := json.Unmarshal(patchBytes, &patch); err != nil {
 		return nil, err
 	}
 
-	changes := make([]FieldChange, 0, len(patch))
-	for _, operation := range patch {
-		tokens := pointerTokens(operation.Path)
-		path, field := splitPointer(tokens)
+	var oldDoc interface{}
+	if len(oldJSON) > 0 {
+		if err := json.Unmarshal(oldJSON, &oldDoc); err != nil {
+			return nil, err
+		}
+	}
 
-		change := FieldChange{
-			Path:   path,
-			Field:  field,
-			Change: operation.Operation,
+	var newDoc interface{}
+	if len(newJSON) > 0 {
+		if err := json.Unmarshal(newJSON, &newDoc); err != nil {
+			return nil, err
 		}
+	}
 
-		if (operation.Operation == "remove" || operation.Operation == "replace") && operation.Path != "" {
-			if value, err := resolveJSONPointer(oldDoc, operation.Path); err == nil {
-				change.OldValue = value
-			}
+	var changes []FieldChange
+	if err := walkPatch(&changes, nil, patch, oldDoc, newDoc); err != nil {
+		return nil, err
+	}
+	return changes, nil
+}
+
+func walkPatch(changes *[]FieldChange, tokens []string, patchNode, oldNode, newNode interface{}) error {
+	switch typed := patchNode.(type) {
+	case map[string]interface{}:
+		if len(typed) == 0 {
+			return nil
+		}
+		oldMap, _ := oldNode.(map[string]interface{})
+		newMap, _ := newNode.(map[string]interface{})
+		keys := make([]string, 0, len(typed))
+		for key := range typed {
+			keys = append(keys, key)
 		}
+		sort.Strings(keys)
 
-		if (operation.Operation == "add" || operation.Operation == "replace") && operation.Value != nil {
-			change.NewValue = operation.Value
+		for _, key := range keys {
+			var oldChild interface{}
+			var newChild interface{}
+			if oldMap != nil {
+				oldChild = oldMap[key]
+			}
+			if newMap != nil {
+				newChild = newMap[key]
+			}
+			if err := walkPatch(changes, append(tokens, key), typed[key], oldChild, newChild); err != nil {
+				return err
+			}
+		}
+	case []interface{}:
+		return diffArrayNodes(changes, tokens, oldNode, newNode)
+	default:
+		path, field := splitTokens(tokens)
+		change := FieldChange{
+			Path:  path,
+			Field: field,
 		}
 
-		changes = append(changes, change)
+		if patchNode == nil {
+			change.Change = "remove"
+			change.OldValue = oldNode
+		} else {
+			if oldNode == nil {
+				change.Change = "add"
+				change.NewValue = newNode
+			} else {
+				if reflect.DeepEqual(oldNode, newNode) {
+					return nil
+				}
+				change.Change = "replace"
+				change.OldValue = oldNode
+				change.NewValue = newNode
+			}
+		}
+		*changes = append(*changes, change)
 	}
-
-	return changes, nil
+	return nil
 }
 
-func resolveJSONPointer(doc interface{}, pointer string) (interface{}, error) {
-	if pointer == "" {
-		return doc, nil
-	}
+func diffArrayNodes(changes *[]FieldChange, tokens []string, oldNode, newNode interface{}) error {
+	oldArr, _ := oldNode.([]interface{})
+	newArr, _ := newNode.([]interface{})
 
-	rawTokens := strings.Split(pointer, "/")[1:]
-	tokens := make([]string, 0, len(rawTokens))
-	for _, rawToken := range rawTokens {
-		tokens = append(tokens, decodePointerToken(rawToken))
+	maxLen := len(oldArr)
+	if len(newArr) > maxLen {
+		maxLen = len(newArr)
 	}
 
-	current := doc
+	for i := 0; i < maxLen; i++ {
+		next := append(tokens, strconv.Itoa(i))
+		var oldVal interface{}
+		var newVal interface{}
+		if i < len(oldArr) {
+			oldVal = oldArr[i]
+		}
+		if i < len(newArr) {
+			newVal = newArr[i]
+		}
 
-	for _, rawToken := range tokens {
-		token := rawToken
-		switch typed := current.(type) {
-		case map[string]interface{}:
-			current = typed[token]
-		case []interface{}:
-			if token == "-" {
-				return nil, fmt.Errorf("pointer '-' not addressable")
+		switch {
+		case oldVal != nil && newVal != nil:
+			if reflect.DeepEqual(oldVal, newVal) {
+				continue
+			}
+			subPatch, err := createNodePatch(oldVal, newVal)
+			if err != nil {
+				return err
 			}
-			index, err := strconv.Atoi(token)
-			if err != nil || index < 0 || index >= len(typed) {
-				return nil, fmt.Errorf("invalid array index %s", token)
+			if subPatch == nil {
+				path, field := splitTokens(next)
+				*changes = append(*changes, FieldChange{
+					Path:     path,
+					Field:    field,
+					Change:   "replace",
+					OldValue: oldVal,
+					NewValue: newVal,
+				})
+				continue
 			}
-			current = typed[index]
-		default:
-			return nil, fmt.Errorf("unable to navigate pointer through %T", current)
+			if err := walkPatch(changes, next, subPatch, oldVal, newVal); err != nil {
+				return err
+			}
+		case oldVal != nil:
+			path, field := splitTokens(next)
+			*changes = append(*changes, FieldChange{
+				Path:     path,
+				Field:    field,
+				Change:   "remove",
+				OldValue: oldVal,
+			})
+		case newVal != nil:
+			path, field := splitTokens(next)
+			*changes = append(*changes, FieldChange{
+				Path:     path,
+				Field:    field,
+				Change:   "add",
+				NewValue: newVal,
+			})
 		}
 	}
 
-	return current, nil
+	return nil
 }
 
-func containsKind(list []string, target string) bool {
-	for _, item := range list {
-		if item == target {
-			return true
-		}
+func createNodePatch(oldNode, newNode interface{}) (interface{}, error) {
+	oldJSON, err := json.Marshal(oldNode)
+	if err != nil {
+		return nil, err
 	}
-	return false
-}
-
-func pointerTokens(pointer string) []string {
-	if pointer == "" {
-		return nil
+	newJSON, err := json.Marshal(newNode)
+	if err != nil {
+		return nil, err
+	}
+	patchBytes, err := jsonpatch.CreateMergePatch(oldJSON, newJSON)
+	if err != nil {
+		return nil, err
 	}
-	rawTokens := strings.Split(pointer, "/")[1:]
-	tokens := make([]string, 0, len(rawTokens))
-	for _, token := range rawTokens {
-		tokens = append(tokens, decodePointerToken(token))
+	trimmed := bytes.TrimSpace(patchBytes)
+	if len(trimmed) == 0 || bytes.Equal(trimmed, []byte("{}")) {
+		return nil, nil
 	}
-	return tokens
-}
-
-func decodePointerToken(token string) string {
-	token = strings.ReplaceAll(token, "~1", "/")
-	token = strings.ReplaceAll(token, "~0", "~")
-	return token
+	var patch interface{}
+	if err := json.Unmarshal(patchBytes, &patch); err != nil {
+		return nil, err
+	}
+	return patch, nil
 }
 
-func splitPointer(tokens []string) (string, string) {
+func splitTokens(tokens []string) (string, string) {
 	if len(tokens) == 0 {
 		return "", ""
 	}
-	parent := formatPath(tokens[:len(tokens)-1])
-	field := tokens[len(tokens)-1]
-	return parent, field
+	return formatPath(tokens[:len(tokens)-1]), tokens[len(tokens)-1]
+}
+
+func containsKind(list []string, target string) bool {
+	for _, item := range list {
+		if item == target {
+			return true
+		}
+	}
+	return false
 }
 
 func formatPath(tokens []string) string {

go.mod

@@ -120,7 +120,6 @@ require (
 	golang.org/x/sys v0.38.0 // indirect
 	golang.org/x/text v0.31.0 // indirect
 	golang.org/x/time v0.12.0 // indirect
-	gomodules.xyz/jsonpatch/v2 v2.5.0 // indirect
 	google.golang.org/protobuf v1.36.6 // indirect
 	gopkg.in/evanphx/json-patch.v4 v4.12.0 // indirect
 	gopkg.in/inf.v0 v0.9.1 // indirect

go.sum

@@ -412,8 +412,6 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gomodules.xyz/jsonpatch/v2 v2.5.0 h1:JELs8RLM12qJGXU4u/TO3V25KW8GreMKl9pdkk14RM0=
-gomodules.xyz/jsonpatch/v2 v2.5.0/go.mod h1:AH3dM2RI6uoBZxn3LVrfvJ3E0/9dG4cSrbuBJT4moAY=
 google.golang.org/genproto/googleapis/api v0.0.0-20250303144028-a0af3efb3deb h1:p31xT4yrYrSM/G4Sn2+TNUkVhFCbG9y8itM2S6Th950=
 google.golang.org/genproto/googleapis/api v0.0.0-20250303144028-a0af3efb3deb/go.mod h1:jbe3Bkdp+Dh2IrslsFCklNhweNTBgSYanP1UXhJDhKg=
 google.golang.org/genproto/googleapis/rpc v0.0.0-20250303144028-a0af3efb3deb h1:TLPQVbx1GJ8VKZxz52VAxl1EBgKXXbTiU9Fc5fZeLn4=