deepmerge function

Author: mandelsoft

README.md

@@ -125,6 +125,7 @@ Contents:
 		- [(( makemap(fieldlist) ))](#-makemapfieldlist-)
 		- [(( makemap(key, value) ))](#-makemapkey-value-)
 		- [(( merge(map1, map2) ))](#-mergemap1-map2-)
+		- [(( deepmerge(map1, map2) ))](#-deepmergemap1-map2-)
 		- [(( intersect(list1, list2) ))](#-intersectlist1-list2-)
 		- [(( reverse(list) ))](#-reverselist-)
 		- [(( parse(yamlorjson) ))](#-parseyamlorjson-)
@@ -781,6 +782,7 @@ yields the list `[ 1, 2, 3, "alice" ]` for `bar`.
 ### `(( map1 map2 ))`
 
 Concatenation of maps as expression. Any sequences of maps can be concatenated, given by any dynaml expression. Thereby entries will be merged. Entries with the same key are overwritten from left to right.
+This is a flat map merge, only top level entries are merged. If you want a deep merge you can use [deepmerge(map1, map2)](#-deepmergemap1-map2-)
 
 e.g.:
 
@@ -2826,6 +2828,54 @@ merged:
   sum: 49
 ```
 
+### `(( deepmerge(map1, map2) ))`
+
+The `merge` function provides a spiff-like merge used for merging templates and stubs. Hereby, only existing entries can be overwritten.
+If a formal deep merge of map entries is required, the `deepmerge` function can be used.
+
+If an entry in both maps is a again a map, those maps are merged recursively, again.
+It is possible to give any number of maps as arguments to `deepmerge`.
+Alternatively a single list of maps can be given.
+Merging is done from left to right, where values in later maps replace left values.
+
+e.g.:
+
+```yaml
+map1:
+    a: a
+    b: b
+    c:
+        a: ca
+        b: cb
+    d: d
+
+map2:
+    a: 2a
+    c:
+        a: 2ca
+        c: 2cc
+    d:
+        a: 2da
+    e: 2e
+
+merged: (( deepmerge(map1,map2) ))
+```
+
+resolves `merged` to
+
+```yaml
+merged:
+    a: 2a
+    b: b
+    c:
+        a: 2ca
+        b: cb
+        c: 2cc
+    d:
+        a: 2da
+    e: 2e
+```
+
 ### `(( intersect(list1, list2) ))`
 
 The function `intersect` intersects multiple lists. A list may contain entries

dynaml/call.go

@@ -275,6 +275,9 @@ func (e CallExpr) Evaluate(binding Binding, locally bool) (interface{}, Evaluati
 	case "merge":
 		result, sub, ok = func_merge(values, binding)
 
+	case "deepmerge":
+		result, sub, ok = func_deepmerge(values, binding)
+
 	case "base64":
 		result, sub, ok = func_base64(values, binding)
 	case "base64_decode":

dynaml/deepmerge.go

@@ -0,0 +1,35 @@
+package dynaml
+
+import (
+	"github.com/mandelsoft/spiff/yaml"
+)
+
+func func_deepmerge(arguments []interface{}, binding Binding) (interface{}, EvaluationInfo, bool) {
+	info := DefaultInfo()
+
+	if len(arguments) < 1 {
+		return nil, info, false
+	}
+
+	maps, msg := getMapList(arguments)
+	if maps == nil {
+		return info.Error("deepmerge: %s", msg)
+	}
+	result := make(map[string]yaml.Node)
+	for _, v := range maps {
+		deepmerge(result, v)
+	}
+	return result, info, true
+}
+
+func deepmerge(result map[string]yaml.Node, m map[string]yaml.Node) {
+	for k, v := range m {
+		if isMap(result[k]) && isMap(v) {
+			r := make(map[string]yaml.Node)
+			concatenateMap(r, result[k].Value().(map[string]yaml.Node))
+			deepmerge(r, v.Value().(map[string]yaml.Node))
+			v = yaml.NewNode(r, "<deepmerge>")
+		}
+		result[k] = v
+	}
+}

dynaml/mapmerge.go

@@ -2,6 +2,7 @@ package dynaml
 
 import (
 	"fmt"
+
 	"github.com/mandelsoft/spiff/yaml"
 )
 
@@ -12,31 +13,14 @@ func func_merge(arguments []interface{}, binding Binding) (interface{}, Evaluati
 		return info.Error("at least one argument required for merge function")
 	}
 
-	args := []yaml.Node{}
-
-	if len(arguments) == 1 {
-		l, ok := arguments[0].([]yaml.Node)
-		if ok {
-			for i, e := range l {
-				m, err := getMap(i, e.Value())
-				if err != nil {
-					return info.Error("merge: entry of list argument: %s", err)
-				}
-				args = append(args, yaml.NewNode(m, "dynaml"))
-			}
-			if len(args) == 0 {
-				return info.Error("merge: no map found for merge")
-			}
-		}
+	maps, msg := getMapList(arguments)
+	if maps == nil {
+		return info.Error("merge: %s", msg)
 	}
-	if len(args) == 0 {
-		for i, arg := range arguments {
-			m, err := getMap(i, arg)
-			if err != nil {
-				return info.Error("merge: argument %s", err)
-			}
-			args = append(args, yaml.NewNode(m, "dynaml"))
-		}
+
+	args := make([]yaml.Node, len(maps))
+	for i, m := range maps {
+		args[i] = yaml.NewNode(m, "dynaml")
 	}
 	result, err := binding.Cascade(binding, args[0], false, args[1:]...)
 	if err != nil {
@@ -62,3 +46,33 @@ func getMap(n int, arg interface{}) (map[string]yaml.Node, error) {
 	}
 	return nil, fmt.Errorf("%d: no map or map template, but %s", n+1, ExpressionType(arg))
 }
+
+func getMapList(arguments []interface{}) ([]map[string]yaml.Node, string) {
+	args := []map[string]yaml.Node{}
+
+	if len(arguments) == 1 {
+		l, ok := arguments[0].([]yaml.Node)
+		if ok {
+			for i, e := range l {
+				m, err := getMap(i, e.Value())
+				if err != nil {
+					return nil, fmt.Sprintf("entry of list argument: %s", err)
+				}
+				args = append(args, m)
+			}
+			if len(args) == 0 {
+				return nil, "no map found for merge"
+			}
+		}
+	}
+	if len(args) == 0 {
+		for i, arg := range arguments {
+			m, err := getMap(i, arg)
+			if err != nil {
+				return nil, fmt.Sprintf("argument %s", err)
+			}
+			args = append(args, m)
+		}
+	}
+	return args, ""
+}

flow/flow_deepmerge_test.go

@@ -0,0 +1,91 @@
+package flow
+
+import (
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Flowing YAML with deepmerge functipn", func() {
+	It("handles multiple maps", func() {
+		source := parseYAML(`
+---
+in:
+  <<: (( &temporary ))
+  map1:
+    a: a
+    b: b
+    c:
+      a: ca
+      b: cb
+    d: d
+
+  map2:
+    a: 2a
+    c:
+      a: 2ca
+      c: 2cc
+    d:
+      a: 2da
+    e: 2e
+
+merge: (( deepmerge(in.map1,in.map2) ))
+`)
+		resolved := parseYAML(`
+---
+merge:
+  a: 2a
+  b: b
+  c:
+    a: 2ca
+    b: cb
+    c: 2cc
+  d:
+    a: 2da
+  e: 2e
+`)
+		Expect(source).To(FlowAs(resolved))
+	})
+
+	It("handles multiple map list", func() {
+		source := parseYAML(`
+---
+in:
+  <<: (( &temporary ))
+  map1:
+    a: a
+    b: b
+    c:
+      a: ca
+      b: cb
+    d: d
+
+  map2:
+    a: 2a
+    c:
+      a: 2ca
+      c: 2cc
+    d:
+      a: 2da
+    e: 2e
+  list:
+    - (( map1 ))
+    - (( map2 ))
+
+merge: (( deepmerge(in.list) ))
+`)
+		resolved := parseYAML(`
+---
+merge:
+  a: 2a
+  b: b
+  c:
+    a: 2ca
+    b: cb
+    c: 2cc
+  d:
+    a: 2da
+  e: 2e
+`)
+		Expect(source).To(FlowAs(resolved))
+	})
+})