Merge branch 'fix/version' of github.com:pubgo/funk into fix/version

Author: kooksee

config/aaa.go

@@ -6,12 +6,12 @@ type NamedConfig interface {
 }
 
 type Resources struct {
-	// Resources resource config file must exist
+	// Resources resource config file or dir must exist
 	Resources []string `yaml:"resources"`
 
-	// PatchResources resource config not required to exist
+	// PatchResources resource config file or dir not required to exist
 	PatchResources []string `yaml:"patch_resources"`
 
-	// PatchEnvs config file or path, not required to exist
+	// PatchEnvs env config file or dir not required to exist
 	PatchEnvs []string `yaml:"patch_envs"`
 }

config/config.go

@@ -10,17 +10,18 @@ import (
 	"strings"
 
 	"github.com/a8m/envsubst"
+	"github.com/rs/zerolog"
 	"github.com/samber/lo"
 	"gopkg.in/yaml.v3"
 
 	"github.com/pubgo/funk/assert"
-	"github.com/pubgo/funk/errors"
 	"github.com/pubgo/funk/log"
+	"github.com/pubgo/funk/log/logfields"
 	"github.com/pubgo/funk/pathutil"
 	"github.com/pubgo/funk/pretty"
 	"github.com/pubgo/funk/recovery"
-	"github.com/pubgo/funk/result"
 	"github.com/pubgo/funk/typex"
+	"github.com/pubgo/funk/v2/result"
 	"github.com/pubgo/funk/vars"
 )
 
@@ -48,49 +49,55 @@ func init() {
 
 func GetConfigData(cfgPath string) (_ []byte, gErr error) {
 	var configBytes []byte
-	defer recovery.Err(&gErr, func(err error) error {
+	defer result.RecoveryErr(&gErr, func(err error) error {
 		log.Err(err).Str("config_path", cfgPath).Msgf("config: %s", configBytes)
 		return err
 	})
 
-	configBytes = result.Of(os.ReadFile(cfgPath)).Expect("failed to read config data: %s", cfgPath)
+	configBytes = result.Wrap(os.ReadFile(cfgPath)).Expect("failed to read config data: %s", cfgPath)
 	configBytes = cfgFormat(configBytes, &config{workDir: filepath.Dir(cfgPath)})
-	configBytes = result.Of(envsubst.Bytes(configBytes)).Expect("failed to handler config env data: %s", cfgPath)
+	configBytes = result.Wrap(envsubst.Bytes(configBytes)).Expect("failed to handler config env data: %s", cfgPath)
 	return configBytes, nil
 }
 
-func LoadEnvConfigMap(cfgPath string) EnvConfigMap { return loadEnvConfigMap(cfgPath) }
+func LoadEnvConfigMap(cfgPath string) EnvSpecMap { return loadEnvConfigMap(cfgPath) }
+
+func loadEnvConfigMap(cfgPath string) EnvSpecMap {
+	defer recovery.Exit(func(err error) error {
+		log.Err(err).Str("path", cfgPath).Msg("load env config map error")
+		return err
+	})
 
-func loadEnvConfigMap(cfgPath string) EnvConfigMap {
 	var res Resources
-	configBytes := result.Of(os.ReadFile(cfgPath)).Expect("failed to read config data: %s", cfgPath)
+	configBytes := result.Wrap(os.ReadFile(cfgPath)).Expect("failed to read config data: %s", cfgPath)
 	assert.Must(yaml.Unmarshal(configBytes, &res), "failed to unmarshal resource config")
 
 	parentDir := filepath.Dir(cfgPath)
-	var envCfgMap EnvConfigMap
+	var envSpecMap EnvSpecMap
 	for _, envPath := range res.PatchEnvs {
 		envPath = filepath.Join(parentDir, envPath)
 		if pathutil.IsNotExist(envPath) {
-			log.Warn().Str("env_path", envPath).Msg("env config cfgPath not found")
+			log.Warn().Str("env_path", envPath).Msg("env config path not found")
 			continue
 		}
 
-		pathList := listAllPath(envPath).Expect("failed to list envPath: %s", envPath)
+		pathList := listAllPath(envPath).Expect("failed to list env config path: %s", envPath)
 		for _, p := range pathList {
-			envConfigBytes := result.Of(os.ReadFile(p)).Expect("failed to handler env config data, path=%s", p)
+			envConfigBytes := result.Wrap(os.ReadFile(p)).Expect("failed to handler env config data, path=%s", p)
 			envConfigBytes = bytes.TrimSpace(envConfigBytes)
 			if len(envConfigBytes) == 0 {
 				continue
 			}
 
-			assert.MustF(yaml.Unmarshal(envConfigBytes, &envCfgMap), "failed to unmarshal env config, data=%s path=%s", envConfigBytes, p)
+			envConfigBytes = result.Wrap(envsubst.Bytes(envConfigBytes)).Expect("failed to handler config env data: %s", envConfigBytes)
+			assert.MustF(yaml.Unmarshal(envConfigBytes, &envSpecMap), "failed to unmarshal env config, data=%s path=%s", envConfigBytes, p)
 		}
 	}
-	initEnv(envCfgMap)
-	return envCfgMap
+	initEnv(envSpecMap)
+	return envSpecMap
 }
 
-func LoadFromPath[T any](val *T, cfgPath string) EnvConfigMap {
+func LoadFromPath[T any](val *T, cfgPath string) EnvSpecMap {
 	defer recovery.Exit(func(err error) error {
 		log.Err(err).Str("config_path", cfgPath).Msg("failed to load config")
 		return err
@@ -113,7 +120,7 @@ func LoadFromPath[T any](val *T, cfgPath string) EnvConfigMap {
 
 	var envCfgMap = loadEnvConfigMap(cfgPath)
 
-	configBytes := result.Of(GetConfigData(cfgPath)).Expect("failed to handler config data")
+	configBytes := result.Wrap(GetConfigData(cfgPath)).Expect("failed to handler config data")
 	defer recovery.Exit(func(err error) error {
 		log.Err(err).
 			Str("config_path", cfgPath).
@@ -149,16 +156,15 @@ func LoadFromPath[T any](val *T, cfgPath string) EnvConfigMap {
 		return lo.Uniq(resPaths)
 	}
 	getCfg := func(resPath string) T {
-		resBytes := result.Of(GetConfigData(resPath)).Expect("failed to handler config data")
+		resBytes := result.Wrap(GetConfigData(resPath)).Expect("failed to handler config data")
 
 		var cfg1 T
-		result.Err[any](yaml.Unmarshal(resBytes, &cfg1)).
-			Unwrap(func(err error) error {
-				fmt.Println("res_path", resPath)
-				fmt.Println("config_data", string(resBytes))
-				assert.Exit(os.WriteFile(resPath+".err.yml", resBytes, 0666))
-				return errors.Wrap(err, "failed to unmarshal config")
-			})
+		result.ErrOf(yaml.Unmarshal(resBytes, &cfg1)).Must(func(e *zerolog.Event) {
+			fmt.Println("res_path", resPath)
+			fmt.Println("config_data", string(resBytes))
+			assert.Exit(os.WriteFile(resPath+".err.yml", resBytes, 0666))
+			e.Str(logfields.Msg, "failed to unmarshal config")
+		})
 
 		return cfg1
 	}
@@ -210,7 +216,7 @@ func LoadFromPath[T any](val *T, cfgPath string) EnvConfigMap {
 type Cfg[T any] struct {
 	T      T
 	P      *T
-	EnvCfg *EnvConfigMap
+	EnvCfg *EnvSpecMap
 }
 
 func Load[T any]() Cfg[T] {

config/configs/assets/assets.yaml

@@ -2,4 +2,4 @@ assets:
   test_md:
     test_abc:
       secret: ${{embed("test.md")}}
-  path_dir: ${{path_dir()}}
+  path_dir: ${{config_dir()}}

config/envs.go

@@ -7,9 +7,9 @@ import (
 	"github.com/samber/lo"
 )
 
-type EnvConfigMap map[string]*EnvConf
+type EnvSpecMap map[string]*EnvSpec
 
-type EnvConf struct {
+type EnvSpec struct {
 	Name        string `yaml:"name"`
 	Description string `yaml:"description"`
 	Default     string `yaml:"default"`
@@ -19,7 +19,7 @@ type EnvConf struct {
 	Tags        string `yaml:"tags"`
 }
 
-func initEnv(envMap EnvConfigMap) {
+func initEnv(envMap EnvSpecMap) {
 	for name, cfg := range envMap {
 		envData := env.Get(name)
 		envData = strings.TrimSpace(lo.Ternary(envData != "", envData, cfg.Default))

config/util.go

@@ -22,7 +22,7 @@ import (
 	"github.com/pubgo/funk/errors"
 	"github.com/pubgo/funk/log"
 	"github.com/pubgo/funk/pathutil"
-	"github.com/pubgo/funk/result"
+	"github.com/pubgo/funk/v2/result"
 )
 
 func GetConfigDir() string {
@@ -81,16 +81,16 @@ func SetConfigPath(confPath string) {
 	configPath = confPath
 }
 
-func MergeR[A any, B any | *any](dst *A, src ...B) (ret result.Result[*A]) {
+func MergeR[A any, B any | *any](dst *A, src ...B) (r result.Result[*A]) {
 	if len(src) == 0 {
-		return ret.WithVal(dst)
+		return r.WithValue(dst)
 	}
 
 	err := Merge(dst, src...)
 	if err != nil {
-		return ret.WithErr(err)
+		return r.WithErr(err)
 	}
-	return ret.WithVal(dst)
+	return r.WithValue(dst)
 }
 
 func Merge[A any, B any | *any](dst *A, src ...B) error {
@@ -182,7 +182,7 @@ func unmarshalOneOrList[T any](list *[]T, value *yaml.Node) error {
 
 func listAllPath(dirOrPath string) (ret result.Result[[]string]) {
 	if !pathutil.IsDir(dirOrPath) {
-		return ret.WithVal([]string{dirOrPath})
+		return ret.WithValue([]string{dirOrPath})
 	}
 
 	var paths []string
@@ -202,7 +202,7 @@ func listAllPath(dirOrPath string) (ret result.Result[[]string]) {
 	if err != nil {
 		return ret.WithErr(err)
 	}
-	return ret.WithVal(paths)
+	return ret.WithValue(paths)
 }
 
 func makeList(typ reflect.Type, data []reflect.Value) reflect.Value {
@@ -229,7 +229,7 @@ func getEnvData(cfg *config) map[string]any {
 		"get_path_dir": func() string {
 			return cfg.workDir
 		},
-		"path_dir": func() string {
+		"config_dir": func() string {
 			return cfg.workDir
 		},
 		"embed": func(name string) string {

config/util_test.go

@@ -53,10 +53,6 @@ func TestEnv(t *testing.T) {
 	data, err = envsubst.String("${hello:-abc}")
 	assert.Nil(t, err)
 	assert.Equal(t, data, "abc")
-
-	data, err = envsubst.String("${{hello:-abc}}")
-	assert.Nil(t, err)
-	assert.Equal(t, data, "${{hello:-abc}}")
 }
 
 func TestConfigPath(t *testing.T) {

env/reload.go

@@ -8,6 +8,10 @@ import (
 	"github.com/rs/zerolog/log"
 )
 
+func init() {
+	loadEnv()
+}
+
 func Reload() {
 	loadEnv()
 }
@@ -35,21 +39,26 @@ func loadEnv() {
 			continue
 		}
 
-		envKey := trim(kvs[0])
-		_ = os.Unsetenv(envKey)
-
-		if envKey == "" ||
-			strings.HasPrefix(envKey, "_") ||
-			strings.HasPrefix(envKey, "=") ||
-			!hasEnvPrefix(envKey, envPrefix) {
-			logRecord(logger.Warn()).Msgf("unset env, key=%s", envKey)
+		rawEnvKey := trim(kvs[0])
+		if rawEnvKey == "" ||
+			strings.HasPrefix(rawEnvKey, "_") ||
+			strings.HasPrefix(rawEnvKey, "=") ||
+			!hasEnvPrefix(rawEnvKey, envPrefix) {
+			logRecord(logger.Warn()).Msgf("unset env, key=%s", rawEnvKey)
+			_ = os.Unsetenv(rawEnvKey)
 			continue
 		}
 
-		key, ok := Normalize(envKey)
+		key, ok := Normalize(rawEnvKey)
 		if ok {
+			if key == rawEnvKey {
+				continue
+			}
+
 			setOk := os.Setenv(key, kvs[1]) == nil
-			logRecord(logger.Info()).Msgf("reset env, old_key=%s new_key=%s set_ok=%v", envKey, key, setOk)
+			logRecord(logger.Info()).Msgf("reset env, old_key=%s new_key=%s set_ok=%v", rawEnvKey, key, setOk)
+		} else {
+			_ = os.Unsetenv(rawEnvKey)
 		}
 	}
 }

env/util_test.go

@@ -13,6 +13,13 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
+func TestResetEnv(t *testing.T) {
+	os.Setenv("abc", "1")
+	t.Log(os.Getenv("abc"))
+	os.Setenv("abc", "2")
+	t.Log(os.Getenv("abc"))
+}
+
 func TestNormalize(t *testing.T) {
 	k, ok := env.Normalize("aA-bS3_AK/c.d")
 	assert.True(t, ok)