Use a single parseJson function

Author: md5

template.go

@@ -216,16 +216,8 @@ func marshalJson(input interface{}) (string, error) {
 	return strings.TrimSuffix(buf.String(), "\n"), nil
 }
 
-func unmarshalJsonArray(input string) ([]interface{}, error) {
-	var v []interface{}
-	if err := json.Unmarshal([]byte(input), &v); err != nil {
-		return nil, err
-	}
-	return v, nil
-}
-
-func unmarshalJsonObject(input string) (interface{}, error) {
-	var v map[string]interface{}
+func unmarshalJson(input string) (interface{}, error) {
+	var v interface{}
 	if err := json.Unmarshal([]byte(input), &v); err != nil {
 		return nil, err
 	}
@@ -301,34 +293,33 @@ func trimSuffix(suffix, s string) string {
 
 func newTemplate(name string) *template.Template {
 	tmpl := template.New(name).Funcs(template.FuncMap{
-		"closest":         arrayClosest,
-		"coalesce":        coalesce,
-		"contains":        contains,
-		"dict":            dict,
-		"dir":             dirList,
-		"exists":          exists,
-		"first":           arrayFirst,
-		"groupBy":         groupBy,
-		"groupByKeys":     groupByKeys,
-		"groupByMulti":    groupByMulti,
-		"hasPrefix":       hasPrefix,
-		"hasSuffix":       hasSuffix,
-		"json":            marshalJson,
-		"intersect":       intersect,
-		"keys":            keys,
-		"last":            arrayLast,
-		"replace":         strings.Replace,
-		"parseJsonArray":  unmarshalJsonArray,
-		"parseJsonObject": unmarshalJsonObject,
-		"sha1":            hashSha1,
-		"split":           strings.Split,
-		"trimPrefix":      trimPrefix,
-		"trimSuffix":      trimSuffix,
-		"where":           where,
-		"whereExist":      whereExist,
-		"whereNotExist":   whereNotExist,
-		"whereAny":        whereAny,
-		"whereAll":        whereAll,
+		"closest":       arrayClosest,
+		"coalesce":      coalesce,
+		"contains":      contains,
+		"dict":          dict,
+		"dir":           dirList,
+		"exists":        exists,
+		"first":         arrayFirst,
+		"groupBy":       groupBy,
+		"groupByKeys":   groupByKeys,
+		"groupByMulti":  groupByMulti,
+		"hasPrefix":     hasPrefix,
+		"hasSuffix":     hasSuffix,
+		"json":          marshalJson,
+		"intersect":     intersect,
+		"keys":          keys,
+		"last":          arrayLast,
+		"replace":       strings.Replace,
+		"parseJson":     unmarshalJson,
+		"sha1":          hashSha1,
+		"split":         strings.Split,
+		"trimPrefix":    trimPrefix,
+		"trimSuffix":    trimSuffix,
+		"where":         where,
+		"whereExist":    whereExist,
+		"whereNotExist": whereNotExist,
+		"whereAny":      whereAny,
+		"whereAll":      whereAll,
 	})
 	return tmpl
 }

template_test.go

@@ -3,6 +3,7 @@ package main
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"reflect"
 	"testing"
 	"text/template"
@@ -518,41 +519,30 @@ func TestJson(t *testing.T) {
 	}
 }
 
-func TestParseJsonArray(t *testing.T) {
-	const expected = "true"
-	const testJson = `[{"enabled":true}]`
-
-	const text = `{{index (parseJsonArray . | first) "enabled"}}`
-	tmpl := template.Must(newTemplate("parseJsonArray-test").Parse(text))
-
-	var b bytes.Buffer
-	err := tmpl.ExecuteTemplate(&b, "parseJsonArray-test", testJson)
-	if err != nil {
-		t.Fatalf("Error executing template: %v", err)
-	}
-
-	got := b.String()
-	if expected != got {
-		t.Fatalf("Incorrect output found; expected %s, got %s", expected, got)
-	}
-}
-
-func TestParseJsonObject(t *testing.T) {
-	const expected = "true"
-	const testJson = `{"enabled":true}`
-
-	const text = `{{index (parseJsonObject .) "enabled"}}`
-	tmpl := template.Must(newTemplate("parseJsonObject-test").Parse(text))
-
-	var b bytes.Buffer
-	err := tmpl.ExecuteTemplate(&b, "parseJsonObject-test", testJson)
-	if err != nil {
-		t.Fatalf("Error executing template: %v", err)
-	}
-
-	got := b.String()
-	if expected != got {
-		t.Fatalf("Incorrect output found; expected %s, got %s", expected, got)
+func TestParseJson(t *testing.T) {
+	tests := []struct {
+		tmpl     string
+		input    string
+		expected string
+	}{
+		{`{{index (parseJson .) "enabled"}}`, `{"enabled":true}`, "true"},
+		{`{{index (parseJson . | first) "enabled"}}`, `[{"enabled":true}]`, "true"},
+	}
+
+	for n, test := range tests {
+		tmplName := fmt.Sprintf("parseJson-test-%d", n)
+		tmpl := template.Must(newTemplate(tmplName).Parse(test.tmpl))
+
+		var b bytes.Buffer
+		err := tmpl.ExecuteTemplate(&b, tmplName, test.input)
+		if err != nil {
+			t.Fatalf("Error executing template: %v", err)
+		}
+
+		got := b.String()
+		if test.expected != got {
+			t.Fatalf("Incorrect output found; expected %s, got %s", test.expected, got)
+		}
 	}
 }