feat: Template functions to replace sets (#242)

Resolves #227

tmpl/context.go

@@ -0,0 +1,15 @@
+package tmpl
+
+import "io/ioutil"
+
+var DefaultContext *Context
+
+func init() {
+	DefaultContext = &Context{
+		readFile: ioutil.ReadFile,
+	}
+}
+
+type Context struct {
+	readFile func(string) ([]byte, error)
+}

tmpl/funcs.go

@@ -0,0 +1,99 @@
+package tmpl
+
+import (
+	"fmt"
+	"gopkg.in/yaml.v2"
+	"os"
+	"strings"
+	"text/template"
+)
+
+type Values = map[string]interface{}
+
+func (c *Context) createFuncMap() template.FuncMap {
+	return template.FuncMap{
+		"readFile":       c.ReadFile,
+		"toYaml":         ToYaml,
+		"fromYaml":       FromYaml,
+		"setValueAtPath": SetValueAtPath,
+		"requiredEnv":    RequiredEnv,
+	}
+}
+
+func (c *Context) ReadFile(filename string) (string, error) {
+	bytes, err := c.readFile(filename)
+	if err != nil {
+		return "", err
+	}
+	return string(bytes), nil
+}
+
+func ToYaml(v interface{}) (string, error) {
+	data, err := yaml.Marshal(v)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
+
+func FromYaml(str string) (Values, error) {
+	m := Values{}
+
+	if err := yaml.Unmarshal([]byte(str), &m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func SetValueAtPath(path string, value interface{}, values Values) (Values, error) {
+	var current interface{}
+	current = values
+	components := strings.Split(path, ".")
+	pathToMap := components[:len(components)-1]
+	key := components[len(components)-1]
+	for _, k := range pathToMap {
+		var elem interface{}
+
+		switch typedCurrent := current.(type) {
+		case map[string]interface{}:
+			v, exists := typedCurrent[k]
+			if !exists {
+				return nil, fmt.Errorf("failed to set value at path \"%s\": value for key \"%s\" does not exist", path, k)
+			}
+			elem = v
+		case map[interface{}]interface{}:
+			v, exists := typedCurrent[k]
+			if !exists {
+				return nil, fmt.Errorf("failed to set value at path \"%s\": value for key \"%s\" does not exist", path, k)
+			}
+			elem = v
+		default:
+			return nil, fmt.Errorf("failed to set value at path \"%s\": value for key \"%s\" was not a map", path, k)
+		}
+
+		switch typedElem := elem.(type) {
+		case map[string]interface{}, map[interface{}]interface{}:
+			current = typedElem
+		default:
+			return nil, fmt.Errorf("failed to set value at path \"%s\": value for key \"%s\" was not a map", path, k)
+		}
+	}
+
+	switch typedCurrent := current.(type) {
+	case map[string]interface{}:
+		typedCurrent[key] = value
+	case map[interface{}]interface{}:
+		typedCurrent[key] = value
+	default:
+		return nil, fmt.Errorf("failed to set value at path \"%s\": value for key \"%s\" was not a map", path, key)
+	}
+	return values, nil
+}
+
+func RequiredEnv(name string) (string, error) {
+	if val, exists := os.LookupEnv(name); exists && len(val) > 0 {
+		return val, nil
+	}
+
+	return "", fmt.Errorf("required env var `%s` is not set", name)
+}

tmpl/funcs_test.go

@@ -0,0 +1,99 @@
+package tmpl
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestReadFile(t *testing.T) {
+	expected := `foo:
+  bar: BAR
+`
+	expectedFilename := "values.yaml"
+	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(expected), nil
+	}}
+	actual, err := ctx.ReadFile(expectedFilename)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf("unexpected result: expected=%v, actual=%v", expected, actual)
+	}
+}
+
+func TestToYaml(t *testing.T) {
+	expected := `foo:
+  bar: BAR
+`
+	vals := Values(map[string]interface{}{
+		"foo": map[interface{}]interface{}{
+			"bar": "BAR",
+		},
+	})
+	actual, err := ToYaml(vals)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf("unexpected result: expected=%v, actual=%v", expected, actual)
+	}
+}
+
+func TestFromYaml(t *testing.T) {
+	raw := `foo:
+  bar: BAR
+`
+	expected := Values(map[string]interface{}{
+		"foo": map[interface{}]interface{}{
+			"bar": "BAR",
+		},
+	})
+	actual, err := FromYaml(raw)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf("unexpected result: expected=%v, actual=%v", expected, actual)
+	}
+}
+
+func TestSetValueAtPath_OneComponent(t *testing.T) {
+	input := map[string]interface{}{
+		"foo": "",
+	}
+	expected := map[string]interface{}{
+		"foo": "FOO",
+	}
+	actual, err := SetValueAtPath("foo", "FOO", input)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf("unexpected result: expected=%v, actual=%v", expected, actual)
+	}
+}
+
+func TestSetValueAtPath_TwoComponents(t *testing.T) {
+	input := map[string]interface{}{
+		"foo": map[interface{}]interface{}{
+			"bar": "",
+		},
+	}
+	expected := map[string]interface{}{
+		"foo": map[interface{}]interface{}{
+			"bar": "FOO_BAR",
+		},
+	}
+	actual, err := SetValueAtPath("foo.bar", "FOO_BAR", input)
+	if err != nil {
+		t.Errorf("unexpected error: %v", err)
+	}
+	if !reflect.DeepEqual(actual, expected) {
+		t.Errorf("unexpected result: expected=%v, actual=%v", expected, actual)
+	}
+}

tmpl/tmpl.go

@@ -0,0 +1,31 @@
+package tmpl
+
+import (
+	"bytes"
+	"github.com/Masterminds/sprig"
+	"text/template"
+)
+
+func (c *Context) stringTemplate() *template.Template {
+	funcMap := sprig.TxtFuncMap()
+	for name, f := range c.createFuncMap() {
+		funcMap[name] = f
+	}
+	return template.New("stringTemplate").Funcs(funcMap)
+}
+
+func (c *Context) RenderTemplateToBuffer(s string) (*bytes.Buffer, error) {
+	var t, parseErr = c.stringTemplate().Parse(s)
+	if parseErr != nil {
+		return nil, parseErr
+	}
+
+	var tplString bytes.Buffer
+	var execErr = t.Execute(&tplString, nil)
+
+	if execErr != nil {
+		return nil, execErr
+	}
+
+	return &tplString, nil
+}

tmpl/tmpl_test.go

@@ -0,0 +1,31 @@
+package tmpl
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+func TestRenderTemplate(t *testing.T) {
+	valuesYamlContent := `foo:
+  bar: BAR
+`
+	expected := `foo:
+  bar: FOO_BAR
+`
+	expectedFilename := "values.yaml"
+	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(`{{ readFile "values.yaml" | fromYaml | setValueAtPath "foo.bar" "FOO_BAR" | toYaml }}`)
+	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)
+	}
+}