feat: get and getOrNil template funcs to allow defaulting in templates (#370)

* feat: `get` and `getOrNil` template funcs to allow defaulting in templates

Ref #357

* Add docs about missing keys and default values in templates

tmpl/funcs.go

@@ -22,6 +22,8 @@ func (c *Context) createFuncMap() template.FuncMap {
 		"fromYaml":       FromYaml,
 		"setValueAtPath": SetValueAtPath,
 		"requiredEnv":    RequiredEnv,
+		"get":            get,
+		"getOrNil":       getOrNil,
 	}
 	if c.preRender {
 		// disable potential side-effect template calls

tmpl/get_or_nil.go

@@ -0,0 +1,60 @@
+package tmpl
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type noValueError struct {
+	msg string
+}
+
+func (e *noValueError) Error() string {
+	return e.msg
+}
+
+func get(path string, obj interface{}) (interface{}, error) {
+	if path == "" {
+		return obj, nil
+	}
+	keys := strings.Split(path, ".")
+	switch typedObj := obj.(type) {
+	case map[string]interface{}:
+		v, ok := typedObj[keys[0]]
+		if !ok {
+			return nil, &noValueError{fmt.Sprintf("no value exist for key \"%s\" in %v", keys[0], typedObj)}
+		}
+		return get(strings.Join(keys[1:], "."), v)
+	case map[interface{}]interface{}:
+		v, ok := typedObj[keys[0]]
+		if !ok {
+			return nil, &noValueError{fmt.Sprintf("no value exist for key \"%s\" in %v", keys[0], typedObj)}
+		}
+		return get(strings.Join(keys[1:], "."), v)
+	default:
+		maybeStruct := reflect.ValueOf(typedObj)
+		if maybeStruct.NumField() < 1 {
+			return nil, &noValueError{fmt.Sprintf("unexpected type(%v) of value for key \"%s\": it must be either map[string]interface{} or any struct", reflect.TypeOf(obj), keys[0])}
+		}
+		f := maybeStruct.FieldByName(keys[0])
+		if !f.IsValid() {
+			return nil, &noValueError{fmt.Sprintf("no field named \"%s\" exist in %v", keys[0], typedObj)}
+		}
+		v := f.Interface()
+		return get(strings.Join(keys[1:], "."), v)
+	}
+}
+
+func getOrNil(path string, o interface{}) (interface{}, error) {
+	v, err := get(path, o)
+	if err != nil {
+		switch err.(type) {
+		case *noValueError:
+			return nil, nil
+		default:
+			return nil, err
+		}
+	}
+	return v, nil
+}

tmpl/get_or_nil_test.go

@@ -0,0 +1,91 @@
+package tmpl
+
+import (
+	"testing"
+)
+
+func TestGetStruct(t *testing.T) {
+	type Foo struct{ Bar string }
+
+	obj := struct{ Foo }{Foo{Bar: "Bar"}}
+
+	v1, err := get("Foo.Bar", obj)
+
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if v1 != "Bar" {
+		t.Errorf("unexpected value for path Foo.Bar in %v: expected=Bar, actual=%v", obj, v1)
+	}
+
+	_, err = get("Foo.baz", obj)
+
+	if err == nil {
+		t.Errorf("expected error but was not occurred")
+	}
+}
+
+func TestGetMap(t *testing.T) {
+	obj := map[string]interface{}{"Foo": map[string]interface{}{"Bar": "Bar"}}
+
+	v1, err := get("Foo.Bar", obj)
+
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if v1 != "Bar" {
+		t.Errorf("unexpected value for path Foo.Bar in %v: expected=Bar, actual=%v", obj, v1)
+	}
+
+	_, err = get("Foo.baz", obj)
+
+	if err == nil {
+		t.Errorf("expected error but was not occurred")
+	}
+}
+
+func TestGetOrNilStruct(t *testing.T) {
+	type Foo struct{ Bar string }
+
+	obj := struct{ Foo }{Foo{Bar: "Bar"}}
+
+	v1, err := getOrNil("Foo.Bar", obj)
+
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if v1 != "Bar" {
+		t.Errorf("unexpected value for path Foo.Bar in %v: expected=Bar, actual=%v", obj, v1)
+	}
+
+	v2, err := getOrNil("Foo.baz", obj)
+
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if v2 != nil {
+		t.Errorf("unexpected value for path Foo.baz in %v: expected=nil, actual=%v", obj, v2)
+	}
+}
+
+func TestGetOrNilMap(t *testing.T) {
+	obj := map[string]interface{}{"Foo": map[string]interface{}{"Bar": "Bar"}}
+
+	v1, err := getOrNil("Foo.Bar", obj)
+
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if v1 != "Bar" {
+		t.Errorf("unexpected value for path Foo.Bar in %v: expected=Bar, actual=%v", obj, v1)
+	}
+
+	v2, err := getOrNil("Foo.baz", obj)
+
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if v2 != nil {
+		t.Errorf("unexpected value for path Foo.baz in %v: expected=nil, actual=%v", obj, v2)
+	}
+}

tmpl/tmpl_test.go

@@ -60,6 +60,56 @@ func TestRenderTemplate_WithData(t *testing.T) {
 	}
 }
 
+func TestRenderTemplate_AccessingMissingKeyWithGetOrNil(t *testing.T) {
+	valuesYamlContent := `foo:
+  bar: {{ . | getOrNil "foo.bar" }}
+`
+	expected := `foo:
+  bar: <no value>
+`
+	expectedFilename := "values.yaml"
+	data := map[string]interface{}{}
+	ctx := &Context{readFile: func(filename string) ([]byte, error) {
+		if filename != expectedFilename {
+			return nil, fmt.Errorf("unexpected filename: expected=%v, actual=%s", expectedFilename, filename)
+		}
+		return []byte(valuesYamlContent), nil
+	}}
+	buf, err := ctx.RenderTemplateToBuffer(valuesYamlContent, data)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	actual := buf.String()
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf("unexpected result: expected=%v, actual=%v", expected, actual)
+	}
+}
+
+func TestRenderTemplate_Defaulting(t *testing.T) {
+	valuesYamlContent := `foo:
+  bar: {{ . | getOrNil "foo.bar" | default "DEFAULT" }}
+`
+	expected := `foo:
+  bar: DEFAULT
+`
+	expectedFilename := "values.yaml"
+	data := map[string]interface{}{}
+	ctx := &Context{readFile: func(filename string) ([]byte, error) {
+		if filename != expectedFilename {
+			return nil, fmt.Errorf("unexpected filename: expected=%v, actual=%s", expectedFilename, filename)
+		}
+		return []byte(valuesYamlContent), nil
+	}}
+	buf, err := ctx.RenderTemplateToBuffer(valuesYamlContent, data)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	actual := buf.String()
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf("unexpected result: expected=%v, actual=%v", expected, actual)
+	}
+}
+
 func renderTemplateToString(s string) (string, error) {
 	ctx := &Context{readFile: func(filename string) ([]byte, error) {
 		return nil, fmt.Errorf("unexpected call to readFile: filename=%s", filename)