Support for strategic-merge (#9)

* Support for strategic-merge

This change, if applied, adds strategic-merge custom merge strategy to
agnosticv.

It can be applied to dict or list using the x-merge key in any schema.

Once this change is merged, we will update in a separate PR the default for `__meta__`
and `agnosticv_meta` variables to use 'strategic-merge' instead of 'merge'.

* Use asciidoc footnote instead of dedicated column

* wording

cli/fixtures/.schemas/schema1.yaml

@@ -5,6 +5,8 @@ x-merge:
     strategy: merge
   - path: /adict/alist
     strategy: merge
+  - path: /adict/strategic_list
+    strategy: strategic-merge
 properties:
   purpose:
     type: string

cli/fixtures/test/BABYLON_EMPTY_CONFIG/common.yaml

@@ -2,6 +2,11 @@
 # Agnosticd variables
 platform: babylon
 
+adict:
+  strategic_list:
+    - name: foo
+      value: common
+
 output_dir: /tmp/output_dir/{{ env_type }}-{{ guid }}
 env_type: test-empty-config
 cloud_provider: test

cli/fixtures/test/BABYLON_EMPTY_CONFIG/prod.yaml

@@ -1,6 +1,11 @@
 ---
 purpose: prod
 
+adict:
+  strategic_list:
+    - name: foo
+      value: prod
+
 #########################################
 # Meta variables for admin host scripts #
 # ALL_agnosticv.sh                      #

cli/fixtures/test/account.yaml

@@ -4,6 +4,9 @@
 
 cloud_provider: none
 adict:
+  strategic_list:
+    - name: foo
+      value: account
   alist:
     - fromaccount
   blist:

cli/merge.go

@@ -12,6 +12,10 @@ import (
 	"github.com/imdario/mergo"
 )
 
+
+// MergeStrategy type to define custom merge strategies.
+// Strategy: the name of the strategy
+// Path: the path in the structure of the vars to apply the strategy against.
 type MergeStrategy struct {
 	Strategy string `json:"strategy,omitempty" yaml:"strategy,omitempty"`
 	Path string `json:"path,omitempty" yaml:"path,omitempty"`
@@ -148,6 +152,16 @@ func customStrategyMerge(final map[string]any, source map[string]any, strategy M
 				logDebug.Println("src", src)
 				logDebug.Println("dst", dst)
 				dst = append(dst, src...)
+
+			case "strategic-merge":
+				logDebug.Printf("customStrategyMerge(%v)  strategic merge", strategy)
+				logDebug.Println("src", src)
+				logDebug.Println("dst", dst)
+				dst = append(dst, src...)
+				if dst, err = strategicCleanupSlice(dst); err != nil {
+					return err
+				}
+
 			default:
 				logErr.Fatal("Unknown merge strategy for list: ", strategy.Strategy)
 			}
@@ -196,6 +210,11 @@ func customStrategyMerge(final map[string]any, source map[string]any, strategy M
 				return err
 			}
 
+		case "strategic-merge":
+			if err := strategicMerge(dstMap, src.(map[string]any)); err != nil {
+				return err
+			}
+
 		default:
 			logErr.Fatal("Unknown merge strategy ", strategy.Strategy)
 		}

cli/merge_test.go

@@ -237,3 +237,31 @@ func TestMergeStrategyOverwrite(t *testing.T) {
 		t.Error("Only myspecialgroup should be present", value, expected)
 	}
 }
+
+func TestMergeStrategicMergeList(t *testing.T) {
+	rootFlag = abs("fixtures")
+	initSchemaList()
+	initMergeStrategies()
+	validateFlag = true
+	merged, _, err := mergeVars(
+		"fixtures/test/BABYLON_EMPTY_CONFIG/prod.yaml",
+		mergeStrategies,
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, value, _, err := Get(merged, "/adict/strategic_list")
+	if err != nil {
+		t.Error(err)
+	}
+	expected := []any{
+		map[string]any{
+			"name": "foo",
+			"value": "prod",
+		},
+	}
+	if !reflect.DeepEqual(value, expected) {
+		t.Error("Only myspecialgroup should be present", value, expected)
+	}
+}

cli/strategic_merge.go

@@ -0,0 +1,90 @@
+package main
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/imdario/mergo"
+)
+
+
+func strategicCleanupSlice(elems []any) ([]any, error) {
+	result := []any{}
+	done := map[string]int{}
+
+	for index, elem := range elems {
+		if reflect.TypeOf(elem).Kind() != reflect.Map {
+			// strategic merge works only on map, if it's not a map, just add the elem and continue
+			result = append(result, elem)
+			continue
+		}
+
+		elemMap := elem.(map[string]any)
+
+
+		if name, ok := elemMap["name"]; ok {
+			if reflect.TypeOf(elemMap["name"]).Kind() != reflect.String {
+				return result, fmt.Errorf("strategic merge cannot work if 'name' is not a string")
+			}
+			nameStr := name.(string)
+			if doneIndex, ok := done[nameStr]; ok {
+				// An element with the same name exists, replace that element
+				result1 := append(result[:doneIndex], elem)
+				result = append(result1, result[doneIndex+1:]...)
+				continue
+			}
+			// Append element
+			result = append(result, elem)
+			done[nameStr] = index
+			continue
+		}
+		result = append(result, elem)
+	}
+
+	return result, nil
+}
+func strategicCleanupMap(m map[string]any) error {
+	for key, v := range m {
+		if v == nil {
+			continue
+		}
+		if reflect.TypeOf(v).Kind() == reflect.Map {
+			vMap := v.(map[string]any)
+
+			if err := strategicCleanupMap(vMap); err != nil {
+				return err
+			}
+			continue
+		}
+
+		if reflect.TypeOf(v).Kind() == reflect.Slice {
+			vSlice := v.([]any)
+			res, err := strategicCleanupSlice(vSlice)
+			if err != nil {
+				return err
+			}
+
+			m[key] = res
+			continue
+		}
+	}
+
+	return nil
+}
+
+func strategicMerge(dst map[string]any, src map[string]any) error {
+	if err := mergo.Merge(
+		&dst,
+		src,
+		mergo.WithOverride,
+		mergo.WithOverwriteWithEmptyValue,
+		mergo.WithAppendSlice,
+	); err != nil {
+		return err
+	}
+
+	if err := strategicCleanupMap(dst); err != nil {
+		return err
+	}
+	return nil
+}