Function walkPatch

diff/structured.go:192–247

(changes *[]FieldChange, tokens []string, patchNode, oldNode, newNode interface{})

}

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)

		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,
		}

		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 nil
}

func diffArrayNodes(changes *[]FieldChange, tokens []string, oldNode, newNode interface{}) error {