add buildin functions xml/ini/yaml/toml for package gview

encoding/gini/gini.go

@@ -81,20 +81,32 @@ func Decode(data []byte) (res map[string]interface{}, err error) {
 // Encode converts map to INI format.
 func Encode(data map[string]interface{}) (res []byte, err error) {
 	var (
-		n int
-		w = new(bytes.Buffer)
+		n  int
+		w  = new(bytes.Buffer)
+		m  map[string]interface{}
+		ok bool
 	)
-	for k, v := range data {
-		n, err = w.WriteString(fmt.Sprintf("[%s]\n", k))
-		if err != nil || n == 0 {
-			return nil, gerror.Wrapf(err, "w.WriteString failed")
-		}
-		for kk, vv := range v.(map[string]interface{}) {
-			n, err = w.WriteString(fmt.Sprintf("%s=%s\n", kk, vv.(string)))
+	for section, item := range data {
+		// Section key-value pairs.
+		if m, ok = item.(map[string]interface{}); ok {
+			n, err = w.WriteString(fmt.Sprintf("[%s]\n", section))
 			if err != nil || n == 0 {
 				return nil, gerror.Wrapf(err, "w.WriteString failed")
 			}
+			for k, v := range m {
+				if n, err = w.WriteString(fmt.Sprintf("%s=%v\n", k, v)); err != nil || n == 0 {
+					return nil, gerror.Wrapf(err, "w.WriteString failed")
+				}
+			}
+			continue
 		}
+		// Simple key-value pairs.
+		for k, v := range data {
+			if n, err = w.WriteString(fmt.Sprintf("%s=%v\n", k, v)); err != nil || n == 0 {
+				return nil, gerror.Wrapf(err, "w.WriteString failed")
+			}
+		}
+		break
 	}
 	res = make([]byte, w.Len())
 	if n, err = w.Read(res); err != nil || n == 0 {

encoding/gjson/gjson_api_encoding.go

@@ -172,7 +172,7 @@ func (j *Json) MustToTomlString() string {
 func (j *Json) ToIni() ([]byte, error) {
 	j.mu.RLock()
 	defer j.mu.RUnlock()
-	return gini.Encode((*(j.p)).(map[string]interface{}))
+	return gini.Encode(j.Map())
 }
 
 // ToIniString ini to string

encoding/gjson/gjson_stdlib_json_util.go

@@ -20,6 +20,21 @@ func Valid(data interface{}) bool {
 	return json.Valid(gconv.Bytes(data))
 }
 
+// Marshal is alias of Encode in order to fit the habit of json.Marshal/Unmarshal functions.
+func Marshal(v interface{}) (marshaledBytes []byte, err error) {
+	return Encode(v)
+}
+
+// MarshalIndent is alias of json.MarshalIndent in order to fit the habit of json.MarshalIndent function.
+func MarshalIndent(v interface{}, prefix, indent string) (marshaledBytes []byte, err error) {
+	return json.MarshalIndent(v, prefix, indent)
+}
+
+// Unmarshal is alias of DecodeTo in order to fit the habit of json.Marshal/Unmarshal functions.
+func Unmarshal(data []byte, v interface{}) (err error) {
+	return DecodeTo(data, v)
+}
+
 // Encode encodes any golang variable `value` to JSON bytes.
 func Encode(value interface{}) ([]byte, error) {
 	return json.Marshal(value)

encoding/gyaml/gyaml_z_unit_test.go

@@ -38,6 +38,27 @@ dd = 11
     cache = "127.0.0.1:6379,1"
 `
 
+func Test_Encode(t *testing.T) {
+	// Map.
+	gtest.C(t, func(t *gtest.T) {
+		b, err := gyaml.Encode(g.Map{
+			"k": "v",
+		})
+		t.AssertNil(err)
+		t.Assert(string(b), `k: v
+`)
+	})
+	// Array.
+	gtest.C(t, func(t *gtest.T) {
+		b, err := gyaml.Encode([]string{"a", "b", "c"})
+		t.AssertNil(err)
+		t.Assert(string(b), `- a
+- b
+- c
+`)
+	})
+}
+
 func Test_Decode(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		result, err := gyaml.Decode([]byte(yamlStr))

internal/json/json.go

@@ -27,7 +27,7 @@ func Marshal(v interface{}) (marshaledBytes []byte, err error) {
 	return
 }
 
-// MarshalIndent same as json.MarshalIndent. Prefix is not supported.
+// MarshalIndent same as json.MarshalIndent.
 func MarshalIndent(v interface{}, prefix, indent string) (marshaledBytes []byte, err error) {
 	marshaledBytes, err = json.MarshalIndent(v, prefix, indent)
 	if err != nil {

os/gview/gview.go

@@ -146,6 +146,10 @@ func New(path ...string) *View {
 		"map":        view.buildInFuncMap,
 		"maps":       view.buildInFuncMaps,
 		"json":       view.buildInFuncJson,
+		"xml":        view.buildInFuncXml,
+		"ini":        view.buildInFuncIni,
+		"yaml":       view.buildInFuncYaml,
+		"toml":       view.buildInFuncToml,
 		"plus":       view.buildInFuncPlus,
 		"minus":      view.buildInFuncMinus,
 		"times":      view.buildInFuncTimes,

os/gview/gview_buildin.go

@@ -14,8 +14,8 @@ import (
 	"strings"
 
 	"github.com/gogf/gf/v2/encoding/ghtml"
+	"github.com/gogf/gf/v2/encoding/gjson"
 	"github.com/gogf/gf/v2/encoding/gurl"
-	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
@@ -224,7 +224,35 @@ func (view *View) buildInFuncNl2Br(str interface{}) string {
 // buildInFuncJson implements build-in template function: json ,
 // which encodes and returns `value` as JSON string.
 func (view *View) buildInFuncJson(value interface{}) (string, error) {
-	b, err := json.Marshal(value)
+	b, err := gjson.Marshal(value)
+	return string(b), err
+}
+
+// buildInFuncXml implements build-in template function: xml ,
+// which encodes and returns `value` as XML string.
+func (view *View) buildInFuncXml(value interface{}, rootTag ...string) (string, error) {
+	b, err := gjson.New(value).ToXml(rootTag...)
+	return string(b), err
+}
+
+// buildInFuncXml implements build-in template function: ini ,
+// which encodes and returns `value` as XML string.
+func (view *View) buildInFuncIni(value interface{}) (string, error) {
+	b, err := gjson.New(value).ToIni()
+	return string(b), err
+}
+
+// buildInFuncYaml implements build-in template function: yaml ,
+// which encodes and returns `value` as YAML string.
+func (view *View) buildInFuncYaml(value interface{}) (string, error) {
+	b, err := gjson.New(value).ToYaml()
+	return string(b), err
+}
+
+// buildInFuncToml implements build-in template function: toml ,
+// which encodes and returns `value` as TOML string.
+func (view *View) buildInFuncToml(value interface{}) (string, error) {
+	b, err := gjson.New(value).ToToml()
 	return string(b), err
 }
 

os/gview/gview_z_unit_test.go

@@ -429,6 +429,57 @@ func Test_BuildInFuncJson(t *testing.T) {
 	})
 }
 
+func Test_BuildInFuncXml(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		v := gview.New()
+		v.Assign("v", g.Map{
+			"name": "john",
+		})
+		r, err := v.ParseContent(context.TODO(), "{{xml .v}}")
+		t.Assert(err, nil)
+		t.Assert(r, `<name>john</name>`)
+	})
+}
+
+func Test_BuildInFuncIni(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		v := gview.New()
+		v.Assign("v", g.Map{
+			"name": "john",
+		})
+		r, err := v.ParseContent(context.TODO(), "{{ini .v}}")
+		t.AssertNil(err)
+		t.Assert(r, `name=john
+`)
+	})
+}
+
+func Test_BuildInFuncYaml(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		v := gview.New()
+		v.Assign("v", g.Map{
+			"name": "john",
+		})
+		r, err := v.ParseContent(context.TODO(), "{{yaml .v}}")
+		t.AssertNil(err)
+		t.Assert(r, `name: john
+`)
+	})
+}
+
+func Test_BuildInFuncToml(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		v := gview.New()
+		v.Assign("v", g.Map{
+			"name": "john",
+		})
+		r, err := v.ParseContent(context.TODO(), "{{toml .v}}")
+		t.AssertNil(err)
+		t.Assert(r, `name = "john"
+`)
+	})
+}
+
 func Test_BuildInFuncPlus(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		v := gview.New()