Simplify template variables with a single 'var' function (#472)

Signed-off-by: David Chung <[email protected]>

Author: David Chung

cmd/cli/base/template.go

@@ -55,7 +55,7 @@ func TemplateProcessor(plugins func() discovery.Plugins) (*pflag.FlagSet, ToJSON
 
 	fs := pflag.NewFlagSet("template", pflag.ExitOnError)
 
-	globals := fs.StringSliceP("global", "g", []string{}, "key=value pairs of 'global' values in template")
+	globals := fs.StringSliceP("var", "v", []string{}, "key=value pairs of globally scoped variagbles")
 	yamlDoc := fs.BoolP("yaml", "y", false, "True if input is in yaml format; json is the default")
 	dump := fs.BoolP("dump", "x", false, "True to dump to output instead of executing")
 

cmd/cli/info/info.go

@@ -67,7 +67,7 @@ func Command(plugins func() discovery.Plugins) *cobra.Command {
 			return err
 		}
 
-		view, err := renderer.Def("plugin", *name, "Plugin name").Render(info)
+		view, err := renderer.Global("plugin", *name).Render(info)
 		if err != nil {
 			return err
 		}
@@ -103,7 +103,7 @@ func Command(plugins func() discovery.Plugins) *cobra.Command {
 			return err
 		}
 
-		view, err := renderer.Def("plugin", *name, "Plugin name").Render(info)
+		view, err := renderer.Global("plugin", *name).Render(info)
 		if err != nil {
 			return err
 		}
@@ -117,7 +117,7 @@ func Command(plugins func() discovery.Plugins) *cobra.Command {
 
 const (
 	apiViewTemplate = `
-Plugin:     {{ref "plugin"}}
+Plugin:     {{var "plugin"}}
 Implements: {{range $spi := .Implements}}{{$spi.Name}}/{{$spi.Version}} {{end}}
 Interfaces: {{range $iface := .Interfaces}}
   SPI:      {{$iface.Name}}/{{$iface.Version}}
@@ -136,7 +136,7 @@ Interfaces: {{range $iface := .Interfaces}}
 
 	funcsViewTemplate = `
 {{range $category, $functions := .}}
-{{ref "plugin"}}/{{$category}} _________________________________________________________________________________________
+{{var "plugin"}}/{{$category}} _________________________________________________________________________________________
   {{range $f := $functions}}
     Name:        {{$f.Name}}
     Description: {{join "\n                 " $f.Description}}

examples/flavor/swarm/templates.go

@@ -12,7 +12,7 @@ set -o xtrace
 mkdir -p /etc/docker
 cat << EOF > /etc/docker/daemon.json
 {
-  "labels": {{ INFRAKIT_LABELS | to_json }}
+  "labels": {{ INFRAKIT_LABELS | jsonEncode }}
 }
 EOF
 
@@ -50,7 +50,7 @@ set -o xtrace
 mkdir -p /etc/docker
 cat << EOF > /etc/docker/daemon.json
 {
-  "labels": {{ INFRAKIT_LABELS | to_json }}
+  "labels": {{ INFRAKIT_LABELS | jsonEncode }}
 }
 EOF
 

pkg/template/funcs.go

@@ -317,57 +317,37 @@ func (t *Template) DefaultFuncs() []Function {
 			},
 		},
 		{
-			Name: "global",
+			Name: "var",
 			Description: []string{
-				"Sets a global variable named after the first argument, with the value as the second argument.",
-				"This is similar to def (which sets the default value).",
-				"Global variables are propagated to all templates that are rendered via the 'include' function.",
+				"References or sets a variable.  If single argument, returns the value.",
+				"If second argument is provided, sets the variable. The scope is global.",
 			},
-			Func: func(n string, v interface{}) Void {
-				t.Global(n, v)
+			Func: func(n string, optional ...interface{}) interface{} {
+				if len(optional) == 0 {
+					return t.Ref(n)
+				}
+				t.Global(n, optional[len(optional)-1])
 				return voidValue
 			},
 		},
 		{
-			Name: "def",
+			Name: "k",
 			Description: []string{
-				"Defines a variable with the first argument as name and last argument value as the default.",
-				"It's also ok to pass a third optional parameter, in the middle, as the documentation string.",
-			},
-			Func: func(name string, args ...interface{}) (Void, error) {
-				if _, has := t.defaults[name]; has {
-					// not sure if this is good, but should complain loudly
-					return voidValue, fmt.Errorf("already defined: %v", name)
-				}
-				var doc string
-				var value interface{}
-				switch len(args) {
-				case 1:
-					// just value, no docs
-					value = args[0]
-				case 2:
-					// docs and value
-					doc = fmt.Sprintf("%v", args[0])
-					value = args[1]
-				}
-				t.Def(name, value, doc)
-				return voidValue, nil
+				"Get value from dictionary by key.",
+				"First arg is the key, second must be a map[string]interface{}",
 			},
-		},
-		{
-			Name: "ref",
-			Description: []string{
-				"References / gets the variable named after the first argument.",
-				"The values must be set first by either def or global.",
+			Func: // MapIndex gets the value of key from map
+			func(k interface{}, m map[string]interface{}) interface{} {
+				return m[fmt.Sprintf("%v", k)]
 			},
-			Func: t.Ref,
 		},
 		{
 			Name: "q",
 			Description: []string{
 				"Runs a JMESPath (http://jmespath.org/) query (first arg) on the object (second arg).",
 				"The return value is an object which needs to be rendered properly for the format of the document.",
-				"Example: {{ include \"https://httpbin.org/get\" | from_json | q \"origin\" }} returns the origin of http request.",
+				"Example: {{ include \"https://httpbin.org/get\" | from_json | q \"origin\" }}",
+				"returns the origin of http request.",
 			},
 			Func: QueryObject,
 		},
@@ -451,16 +431,6 @@ func (t *Template) DefaultFuncs() []Function {
 			},
 			Func: FromINI,
 		},
-		{
-			Name: "k",
-			Description: []string{
-				"Get value from dictionary by key. First arg is the key, second must be a map[string]interface{}",
-			},
-			Func: // MapIndex gets the value of key from map
-			func(k interface{}, m map[string]interface{}) interface{} {
-				return m[fmt.Sprintf("%v", k)]
-			},
-		},
 		{
 			Name: "echo",
 			Description: []string{
@@ -478,32 +448,5 @@ func (t *Template) DefaultFuncs() []Function {
 				return ""
 			},
 		},
-
-		// Deprecated
-		{
-			Name: "to_json",
-			Description: []string{
-				"Encodes the input as a JSON string",
-				"This is useful for taking an object (interface{}) and render it inline as proper JSON.",
-				"Example: {{ include \"https://httpbin.org/get\" | from_json | to_json }}",
-			},
-			Func: ToJSON,
-		},
-		{
-			Name: "to_json_format",
-			Description: []string{
-				"Encodes the input as a JSON string with first arg as prefix, second arg the indentation, then the object",
-			},
-			Func: ToJSONFormat,
-		},
-		{
-			Name: "from_json",
-			Description: []string{
-				"Decodes the input (first arg) into a structure (a map[string]interface{} or []interface{}).",
-				"This is useful for parsing arbitrary resources in JSON format as object.  The object is the queryable via 'q'",
-				"For example: {{ include \"https://httpbin.org/get\" | from_json | q \"origin\" }} returns the origin of request.",
-			},
-			Func: FromJSON,
-		},
 	}
 }

pkg/template/integration_test.go

@@ -8,13 +8,10 @@ import (
 	"sync"
 	"testing"
 
-	"github.com/docker/infrakit/pkg/log"
 	"github.com/docker/infrakit/pkg/types"
 	"github.com/stretchr/testify/require"
 )
 
-var logger = log.New("module", "template")
-
 func TestTemplateInclusionFromDifferentSources(t *testing.T) {
 	prefix := testSetupTemplates(t, testFiles)
 
@@ -88,11 +85,11 @@ echo "this is common/setup.sh"
    "test" : "test1",
    "description" : "simple template to test the various template functions",
    {{/* Load from from ./ using relative path notation. Then split into lines and json encode */}}
-   "userData" : {{ include "script.tpl" . | lines | to_json }},
+   "userData" : {{ include "script.tpl" . | lines | jsonEncode }},
    {{/* Load from an URL */}}
    "sample" : {{ include "https://httpbin.org/get" }},
    {{/* Load from URL and then parse as JSON then select an attribute */}}
-   "originIp" : "{{ include "https://httpbin.org/get" | from_json | q "origin" }}"
+   "originIp" : "{{ include "https://httpbin.org/get" | jsonDecode | q "origin" }}"
 }`,
 
 		"plugin/script.tpl": `
@@ -164,7 +161,7 @@ The message is {{str}}
 }
 
 func TestMissingGlobal(t *testing.T) {
-	s := `{{ if not (ref "/not/exist")}}none{{else}}here{{end}}`
+	s := `{{ if not (var "/not/exist")}}none{{else}}here{{end}}`
 	tt, err := NewTemplate("str://"+s, Options{})
 	require.NoError(t, err)
 	view, err := tt.Render(nil)
@@ -173,28 +170,18 @@ func TestMissingGlobal(t *testing.T) {
 }
 
 func TestSourceAndDef(t *testing.T) {
-	r := `{{ def \"foo\" 100 }}`
-	s := `{{ source "str://` + r + `" }}foo={{ref "foo"}}`
+	r := `{{ var \"foo\" 100 }}`
+	s := `{{ source "str://` + r + `" }}foo={{var "foo"}}`
 	tt, err := NewTemplate("str://"+s, Options{})
 	require.NoError(t, err)
 	view, err := tt.Render(nil)
 	require.NoError(t, err)
 	require.Equal(t, "foo=100", view)
 }
 
-func TestAddDef(t *testing.T) {
-	s := `{{ ref "message" }}: x + y = {{ add (ref "x") (ref "y") }}`
-	tt, err := NewTemplate("str://"+s, Options{})
-	require.NoError(t, err)
-
-	view, err := tt.Def("x", 25, "Default value for x").Def("y", 100, "no doc").Def("message", "hello", "").Render(nil)
-	require.NoError(t, err)
-	require.Equal(t, "hello: x + y = 125", view)
-}
-
 func TestSourceAndGlobal(t *testing.T) {
-	r := `{{ global \"foo\" 100 }}`
-	s := `{{ source "str://` + r + `" }}foo={{ref "foo"}}`
+	r := `{{ var \"foo\" 100 }}`
+	s := `{{ source "str://` + r + `" }}foo={{var "foo"}}`
 	tt, err := NewTemplate("str://"+s, Options{})
 	require.NoError(t, err)
 	view, err := tt.Render(nil)
@@ -203,8 +190,8 @@ func TestSourceAndGlobal(t *testing.T) {
 }
 
 func TestIncludeAndGlobal(t *testing.T) {
-	r := `{{ global \"foo\" 100 }}` // the child template tries to mutate the global
-	s := `{{ include "str://` + r + `" }}foo={{ref "foo"}}`
+	r := `{{ var \"foo\" 100 }}` // the child template tries to mutate the global
+	s := `{{ include "str://` + r + `" }}foo={{var "foo"}}`
 	tt, err := NewTemplate("str://"+s, Options{})
 	require.NoError(t, err)
 	tt.Global("foo", 200) // set the global of the calling / parent template
@@ -218,7 +205,7 @@ func TestSourceAndGlobalWithContext(t *testing.T) {
 		"a": 1,
 		"b": 2,
 	}
-	r := `{{ global \"foo\" 100 }}{{$void := set . \"a\" 100}}` // sourced mutates the context
+	r := `{{ var \"foo\" 100 }}{{$void := set . \"a\" 100}}` // sourced mutates the context
 	s := `{{ source "str://` + r + `" }}a={{.a}}`
 	tt, err := NewTemplate("str://"+s, Options{})
 	require.NoError(t, err)
@@ -232,7 +219,7 @@ func TestIncludeAndGlobalWithContext(t *testing.T) {
 		"a": 1,
 		"b": 2,
 	}
-	r := `{{ global \"foo\" 100 }}{{$void := set . \"a\" 100}}` // included tries to mutate the context
+	r := `{{ var \"foo\" 100 }}{{$void := set . \"a\" 100}}` // included tries to mutate the context
 	s := `{{ include "str://` + r + `" }}a={{.a}}`
 	tt, err := NewTemplate("str://"+s, Options{})
 	require.NoError(t, err)
@@ -264,27 +251,27 @@ func TestWithFunctions(t *testing.T) {
 func TestSourceWithHeaders(t *testing.T) {
 
 	h, context := headersAndContext("foo=bar")
-	logger.Info("result", "context", context, "headers", h)
+	log.Info("result", "context", context, "headers", h)
 	require.Equal(t, interface{}(nil), context)
 	require.Equal(t, map[string][]string{"foo": {"bar"}}, h)
 
 	h, context = headersAndContext("foo=bar", "bar=baz", 224)
-	logger.Info("result", "context", context, "headers", h)
+	log.Info("result", "context", context, "headers", h)
 	require.Equal(t, 224, context)
 	require.Equal(t, map[string][]string{"foo": {"bar"}, "bar": {"baz"}}, h)
 
 	h, context = headersAndContext("foo=bar", "bar=baz")
-	logger.Info("result", "context", context, "headers", h)
+	log.Info("result", "context", context, "headers", h)
 	require.Equal(t, nil, context)
 	require.Equal(t, map[string][]string{"foo": {"bar"}, "bar": {"baz"}}, h)
 
 	h, context = headersAndContext("foo")
-	logger.Info("result", "context", context, "headers", h)
+	log.Info("result", "context", context, "headers", h)
 	require.Equal(t, "foo", context)
 	require.Equal(t, map[string][]string{}, h)
 
 	h, context = headersAndContext("foo=bar", map[string]string{"hello": "world"})
-	logger.Info("result", "context", context, "headers", h)
+	log.Info("result", "context", context, "headers", h)
 	require.Equal(t, map[string]string{"hello": "world"}, context)
 	require.Equal(t, map[string][]string{"foo": {"bar"}}, h)