Replace MergeInto with Patch & Replace rules

keyvalue.go

@@ -6,6 +6,7 @@ import (
 )
 
 const reservedKeyPatch = "patch"
+const reservedKeyReplace = "replace"
 
 // A KeyValue object, that may hold multiple Values
 type KeyValue struct {
@@ -139,37 +140,58 @@ func (node *KeyValue) Parent() *KeyValue {
 	return node.parent
 }
 
+func (node *KeyValue) Patch(parent *KeyValue) (merged KeyValue, err error) {
+	merged = *parent
+	if node.Key() != merged.Key() {
+		// "patch" is a special key that can appear at the root of a keyvalue
+		// it does what it sounds like, its ony real purpose is to patch another tree
+		// with its own values
+		if node.Key() != reservedKeyPatch || node.Parent() == nil || node.Parent().Key() != tokenRootNodeKey {
+			return merged,errors.New("cannot merge mismatched root nodes")
+		}
+		node.key = merged.Key()
+	}
+
+	err = recursiveMerge(node, &merged, false)
+
+	return merged,err
+}
+
 // MergeInto merges this KeyValue tree into another.
 // The resultant tree will contain all nodes in the same tree from both
 // this and the target.
 // In the case where a key exists in both trees, this key's value will
 // replace the parent's value
-func (node *KeyValue) MergeInto(parent *KeyValue) (merged KeyValue, err error) {
+func (node *KeyValue) Replace(parent *KeyValue) (merged KeyValue, err error) {
 	merged = *parent
 	if node.Key() != merged.Key() {
-		// "patch" is a special key that can appear at the root of a keyvalue
-		// it does what it sounds like, its ony real purpose is to patch another tree
-		// with its own values
-		if node.Key() != reservedKeyPatch || node.Parent() == nil || node.Parent().Key() != tokenRootNodeKey {
+		// "replace" is a special key that can appear at the root of a keyvalue
+		// it does what it sounds like, its ony real purpose is to replace another tree's values
+		// with its own values if found, else add them.
+		if node.Key() != reservedKeyReplace || node.Parent() == nil || node.Parent().Key() != tokenRootNodeKey {
 			return merged,errors.New("cannot merge mismatched root nodes")
 		}
 		node.key = merged.Key()
 	}
 
-	err = recursiveMerge(node, &merged)
+	err = recursiveMerge(node, &merged, true)
 
 	return merged,err
 }
 
 // recursiveMerge merge a into b
-// if a.Key() == b.Key(), a will replace b
-func recursiveMerge(a *KeyValue, b *KeyValue) (err error) {
+// if a.Key() == b.Key() && shouldReplace, a will replace b unless they have children, then
+// recurse downwards.
+func recursiveMerge(a *KeyValue, b *KeyValue, shouldReplace bool) (err error) {
 	// Bottem level node on parent tree
 	if b.HasChildren() == false {
 		// only option is to replace b with a, and types must match
 		if a.Key() != b.Key() {
 			return errors.New("mismatched types on keyvalue")
 		}
+		if shouldReplace == false {
+			return nil
+		}
 		b.valueType = a.valueType
 		b.value = a.value
 		return nil
@@ -200,7 +222,7 @@ func recursiveMerge(a *KeyValue, b *KeyValue) (err error) {
 				return err
 			}
 		} else {
-			err = recursiveMerge(children[idx], childB)
+			err = recursiveMerge(children[idx], childB, shouldReplace)
 			if err != nil {
 				return err
 			}

keyvalue_test.go

@@ -165,7 +165,7 @@ func TestKeyValue_AsFloat(t *testing.T) {
 
 func TestKeyValue_MergeInto(t *testing.T) {
 	a := &KeyValue{
-		key: "foo",
+		key: "replace",
 		valueType: ValueArray,
 		value: []interface{}{
 			&KeyValue{
@@ -212,7 +212,7 @@ func TestKeyValue_MergeInto(t *testing.T) {
 		},
 	}
 
-	result,err := a.MergeInto(b)
+	result,err := a.Replace(b)
 	if err != nil {
 		t.Error(err)
 	}
@@ -246,7 +246,7 @@ func TestKeyValue_MergeInto(t *testing.T) {
 
 func TestKeyValue_RemoveChild(t *testing.T) {
 	a := &KeyValue{
-		key: "foo",
+		key: "replace",
 		valueType: ValueArray,
 		value: []interface{}{
 			&KeyValue{
@@ -293,7 +293,7 @@ func TestKeyValue_RemoveChild(t *testing.T) {
 		},
 	}
 
-	result,err := a.MergeInto(b)
+	result,err := a.Replace(b)
 	if err != nil {
 		t.Error(err)
 	}