feat: add toml config (#1899)

core/conf/config.go

@@ -6,12 +6,14 @@ import (
 	"log"
 	"os"
 	"path"
+	"strings"
 
 	"github.com/zeromicro/go-zero/core/mapping"
 )
 
 var loaders = map[string]func([]byte, interface{}) error{
 	".json": LoadFromJsonBytes,
+	".toml": LoadFromTomlBytes,
 	".yaml": LoadFromYamlBytes,
 	".yml":  LoadFromYamlBytes,
 }
@@ -23,7 +25,7 @@ func Load(file string, v interface{}, opts ...Option) error {
 		return err
 	}
 
-	loader, ok := loaders[path.Ext(file)]
+	loader, ok := loaders[strings.ToLower(path.Ext(file))]
 	if !ok {
 		return fmt.Errorf("unrecognized file type: %s", file)
 	}
@@ -57,6 +59,12 @@ func LoadConfigFromJsonBytes(content []byte, v interface{}) error {
 	return LoadFromJsonBytes(content, v)
 }
 
+// LoadFromTomlBytes loads config into v from content toml bytes.
+func LoadFromTomlBytes(content []byte, v interface{}) error {
+	return mapping.UnmarshalTomlBytes(content, v)
+}
+
+// LoadFromYamlBytes loads config into v from content yaml bytes.
 func LoadFromYamlBytes(content []byte, v interface{}) error {
 	return mapping.UnmarshalYamlBytes(content, v)
 }
@@ -69,7 +77,7 @@ func LoadConfigFromYamlBytes(content []byte, v interface{}) error {
 
 // MustLoad loads config into v from path, exits on error.
 func MustLoad(path string, v interface{}, opts ...Option) {
-	if err := LoadConfig(path, v, opts...); err != nil {
+	if err := Load(path, v, opts...); err != nil {
 		log.Fatalf("error: config file %s, %s", path, err.Error())
 	}
 }

core/conf/config_test.go

@@ -11,14 +11,14 @@ import (
 )
 
 func TestLoadConfig_notExists(t *testing.T) {
-	assert.NotNil(t, LoadConfig("not_a_file", nil))
+	assert.NotNil(t, Load("not_a_file", nil))
 }
 
 func TestLoadConfig_notRecogFile(t *testing.T) {
 	filename, err := fs.TempFilenameWithText("hello")
 	assert.Nil(t, err)
 	defer os.Remove(filename)
-	assert.NotNil(t, LoadConfig(filename, nil))
+	assert.NotNil(t, Load(filename, nil))
 }
 
 func TestConfigJson(t *testing.T) {
@@ -57,6 +57,58 @@ func TestConfigJson(t *testing.T) {
 	}
 }
 
+func TestConfigToml(t *testing.T) {
+	text := `a = "foo"
+b = 1
+c = "${FOO}"
+d = "abcd!@#$112"
+`
+	os.Setenv("FOO", "2")
+	defer os.Unsetenv("FOO")
+	tmpfile, err := createTempFile(".toml", text)
+	assert.Nil(t, err)
+	defer os.Remove(tmpfile)
+
+	var val struct {
+		A string `json:"a"`
+		B int    `json:"b"`
+		C string `json:"c"`
+		D string `json:"d"`
+	}
+	MustLoad(tmpfile, &val)
+	assert.Equal(t, "foo", val.A)
+	assert.Equal(t, 1, val.B)
+	assert.Equal(t, "${FOO}", val.C)
+	assert.Equal(t, "abcd!@#$112", val.D)
+}
+
+func TestConfigTomlEnv(t *testing.T) {
+	text := `a = "foo"
+b = 1
+c = "${FOO}"
+d = "abcd!@#112"
+`
+	os.Setenv("FOO", "2")
+	defer os.Unsetenv("FOO")
+	tmpfile, err := createTempFile(".toml", text)
+	assert.Nil(t, err)
+	defer os.Remove(tmpfile)
+
+	var val struct {
+		A string `json:"a"`
+		B int    `json:"b"`
+		C string `json:"c"`
+		D string `json:"d"`
+	}
+
+	MustLoad(tmpfile, &val, UseEnv())
+	assert.Equal(t, "foo", val.A)
+	assert.Equal(t, 1, val.B)
+	assert.Equal(t, "2", val.C)
+	assert.Equal(t, "abcd!@#112", val.D)
+
+}
+
 func TestConfigJsonEnv(t *testing.T) {
 	tests := []string{
 		".json",

core/mapping/tomlunmarshaler.go

@@ -0,0 +1,29 @@
+package mapping
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+
+	"github.com/pelletier/go-toml/v2"
+)
+
+// UnmarshalTomlBytes unmarshals TOML bytes into the given v.
+func UnmarshalTomlBytes(content []byte, v interface{}) error {
+	return UnmarshalTomlReader(bytes.NewReader(content), v)
+}
+
+// UnmarshalTomlReader unmarshals TOML from the given io.Reader into the given v.
+func UnmarshalTomlReader(r io.Reader, v interface{}) error {
+	var val interface{}
+	if err := toml.NewDecoder(r).Decode(&val); err != nil {
+		return err
+	}
+
+	var buf bytes.Buffer
+	if err := json.NewEncoder(&buf).Encode(val); err != nil {
+		return err
+	}
+
+	return UnmarshalJsonReader(&buf, v)
+}

core/mapping/tomlunmarshaler_test.go

@@ -0,0 +1,41 @@
+package mapping
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestUnmarshalToml(t *testing.T) {
+	const input = `a = "foo"
+b = 1
+c = "${FOO}"
+d = "abcd!@#$112"
+`
+	var val struct {
+		A string `json:"a"`
+		B int    `json:"b"`
+		C string `json:"c"`
+		D string `json:"d"`
+	}
+	assert.Nil(t, UnmarshalTomlBytes([]byte(input), &val))
+	assert.Equal(t, "foo", val.A)
+	assert.Equal(t, 1, val.B)
+	assert.Equal(t, "${FOO}", val.C)
+	assert.Equal(t, "abcd!@#$112", val.D)
+}
+
+func TestUnmarshalTomlErrorToml(t *testing.T) {
+	const input = `foo"
+b = 1
+c = "${FOO}"
+d = "abcd!@#$112"
+`
+	var val struct {
+		A string `json:"a"`
+		B int    `json:"b"`
+		C string `json:"c"`
+		D string `json:"d"`
+	}
+	assert.NotNil(t, UnmarshalTomlBytes([]byte(input), &val))
+}

core/stores/sqlx/sqlconn.go

@@ -333,7 +333,6 @@ func (s statement) QueryRowCtx(ctx context.Context, v interface{}, args ...inter
 	return queryStmt(ctx, s.stmt, func(rows *sql.Rows) error {
 		return unmarshalRow(v, rows, true)
 	}, s.query, args...)
-
 }
 
 func (s statement) QueryRowPartial(v interface{}, args ...interface{}) error {