From c72a9f2e1ec112b0eb64f143c3bc518fac71e410 Mon Sep 17 00:00:00 2001 From: John Guo Date: Mon, 17 Jan 2022 15:55:45 +0800 Subject: [PATCH] add buildin functions xml/ini/yaml/toml for package gview --- encoding/gini/gini.go | 30 +++++++++----- encoding/gjson/gjson_api_encoding.go | 2 +- encoding/gjson/gjson_stdlib_json_util.go | 15 +++++++ encoding/gyaml/gyaml_z_unit_test.go | 21 ++++++++++ internal/json/json.go | 2 +- os/gview/gview.go | 4 ++ os/gview/gview_buildin.go | 32 ++++++++++++++- os/gview/gview_z_unit_test.go | 51 ++++++++++++++++++++++++ 8 files changed, 144 insertions(+), 13 deletions(-) diff --git a/encoding/gini/gini.go b/encoding/gini/gini.go index 43dcdf25c..dbc4e9838 100644 --- a/encoding/gini/gini.go +++ b/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 { diff --git a/encoding/gjson/gjson_api_encoding.go b/encoding/gjson/gjson_api_encoding.go index 780233069..f3efa1af3 100644 --- a/encoding/gjson/gjson_api_encoding.go +++ b/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 diff --git a/encoding/gjson/gjson_stdlib_json_util.go b/encoding/gjson/gjson_stdlib_json_util.go index 24c404a82..a51264e99 100644 --- a/encoding/gjson/gjson_stdlib_json_util.go +++ b/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) diff --git a/encoding/gyaml/gyaml_z_unit_test.go b/encoding/gyaml/gyaml_z_unit_test.go index 2e4c8c666..e7b99e9c7 100644 --- a/encoding/gyaml/gyaml_z_unit_test.go +++ b/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)) diff --git a/internal/json/json.go b/internal/json/json.go index 89832110f..7ad3da130 100644 --- a/internal/json/json.go +++ b/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 { diff --git a/os/gview/gview.go b/os/gview/gview.go index fa1ea0ce4..95f9d37e1 100644 --- a/os/gview/gview.go +++ b/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, diff --git a/os/gview/gview_buildin.go b/os/gview/gview_buildin.go index 7df38e75d..076023f7d 100644 --- a/os/gview/gview_buildin.go +++ b/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 } diff --git a/os/gview/gview_z_unit_test.go b/os/gview/gview_z_unit_test.go index 680c129a6..3e558e346 100644 --- a/os/gview/gview_z_unit_test.go +++ b/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, `john`) + }) +} + +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()