chore: quick update fix/version at 2025-09-17 17:07:01

kooksee · kooksee · commit 5921f067a3a5 · 2025-09-17T17:07:02.000+08:00
diff --git a/component/cloudevent/publisher.go b/component/cloudevent/publisher.go
@@ -133,7 +133,7 @@ func (c *Client) publish(ctx context.Context, topic string, args proto.Message,
 		Log(func(e *zerolog.Event) {
 			e.Str(logfields.Msg, "failed to marshal args to any proto")
 		}).
-		Unwrap(&gErr)
+		UnwrapErr(&gErr)
 	if gErr != nil {
 		return
 	}
@@ -143,7 +143,7 @@ func (c *Client) publish(ctx context.Context, topic string, args proto.Message,
 		Log(func(e *zerolog.Event) {
 			e.Str(logfields.Msg, "failed to marshal any proto to bytes")
 		}).
-		Unwrap(&gErr)
+		UnwrapErr(&gErr)
 	if gErr != nil {
 		return
 	}
@@ -167,7 +167,7 @@ func (c *Client) publish(ctx context.Context, topic string, args proto.Message,
 		Log(func(e *zerolog.Event) {
 			e.Str(logfields.Msg, fmt.Sprintf("failed to publish msg to stream, topic=%s msg_id=%s", topic, msgId))
 		}).
-		Unwrap(&gErr)
+		UnwrapErr(&gErr)
 	if gErr != nil {
 		return
 	}
diff --git a/env/env.go b/env/env.go
@@ -120,7 +120,7 @@ func Key(key string) string {
 
 func LoadFiles(files ...string) (r result.Error) {
 	files = lo.Filter(files, func(item string, index int) bool { return pathutil.IsExist(item) })
-	if result.CatchErr(&r, godotenv.Load(files...)) {
+	if result.Catch(&r, godotenv.Load(files...)) {
 		return
 	}
 
diff --git a/log/z_log_test.go b/log/z_log_test.go
@@ -15,6 +15,12 @@ import (
 	"github.com/pubgo/funk/log/logutil"
 )
 
+func TestLogLevel(t *testing.T) {
+	log.Warn().Msg("test warn")
+	logger := log.GetLogger().WithLevel(zerolog.ErrorLevel)
+	logger.Warn().Msg("test warn")
+}
+
 func TestWithName(t *testing.T) {
 	log.GetLogger("log1").
 		Debug().
diff --git a/v2/result/api.go b/v2/result/api.go
@@ -106,27 +106,25 @@ func WrapFn[T any](fn func() (T, error)) Result[T] {
 	return Result[T]{err: err}
 }
 
-func CatchErr(setter ErrSetter, err error, contexts ...context.Context) bool {
+func Catch(setter ErrSetter, err error, contexts ...context.Context) bool {
 	return catchErr(newError(err), setter, nil, contexts...)
 }
 
-func Catch(rawSetter *error, err error, contexts ...context.Context) bool {
+func CatchErr(rawSetter *error, err error, contexts ...context.Context) bool {
 	return catchErr(newError(err), nil, rawSetter, contexts...)
 }
 
 func MapTo[T, U any](r Result[T], fn func(T) U) Result[U] {
 	if r.IsErr() {
-		err := errors.WrapCaller(r.getErr(), 1)
-		return Fail[U](err)
+		return Fail[U](errors.WrapCaller(r.getErr(), 1))
 	}
 
 	return OK(fn(r.getValue()))
 }
 
 func FlatMapTo[T, U any](r Result[T], fn func(T) Result[U]) Result[U] {
 	if r.IsErr() {
-		err := errors.WrapCaller(r.getErr(), 1)
-		return Fail[U](err)
+		return Fail[U](errors.WrapCaller(r.getErr(), 1))
 	}
 
 	return fn(r.getValue())
diff --git a/v2/result/error.go b/v2/result/error.go
@@ -71,16 +71,11 @@ func (e Error) Inspect(fn func(error)) Error {
 
 func (e Error) InspectErr(fn func(error)) Error { return e.Inspect(fn) }
 
-func (e Error) Unwrap() error { return e.err }
-func (e Error) UnwrapErr(setter ErrSetter, contexts ...context.Context) bool {
-	return catchErr(e, setter, nil, contexts...)
-}
-
-func (e Error) Catch(setter *error, ctx ...context.Context) bool {
+func (e Error) CatchErr(setter *error, ctx ...context.Context) bool {
 	return catchErr(e, nil, setter, ctx...)
 }
 
-func (e Error) CatchErr(setter ErrSetter, ctx ...context.Context) bool {
+func (e Error) Catch(setter ErrSetter, ctx ...context.Context) bool {
 	return catchErr(e, setter, nil, ctx...)
 }
 
diff --git a/v2/result/interface.go b/v2/result/interface.go
@@ -2,11 +2,6 @@ package result
 
 import "context"
 
-type Catchable interface {
-	Catch(err *error, contexts ...context.Context) bool
-	CatchErr(err ErrSetter, contexts ...context.Context) bool
-}
-
 // Checkable defines types that can be checked for Ok/Error state
 type Checkable interface {
 	IsOK() bool
@@ -20,7 +15,12 @@ type ErrSetter interface {
 	setErrorInner()
 }
 
+type Catchable interface {
+	CatchErr(err *error, contexts ...context.Context) bool
+	Catch(err ErrSetter, contexts ...context.Context) bool
+}
+
 type UnWrapper[T any] interface {
-	Unwrap(setter *error, contexts ...context.Context) T
-	UnwrapErr(setter ErrSetter, contexts ...context.Context) T
+	UnwrapErr(setter *error, contexts ...context.Context) T
+	Unwrap(setter ErrSetter, contexts ...context.Context) T
 }
diff --git a/v2/result/proxy_test.go b/v2/result/proxy_test.go
@@ -9,7 +9,7 @@ import (
 func TestProxy(t *testing.T) {
 	var gErr error
 	var err = ErrProxyOf(&gErr)
-	Errorf("test proxy error").Log().CatchErr(&err)
+	Errorf("test proxy error").Log().Catch(&err)
 	assert.NotNil(t, gErr)
 	assert.NotNil(t, err.GetErr())
 	assert.Equal(t, gErr, err.GetErr())
diff --git a/v2/result/result.go b/v2/result/result.go
@@ -82,11 +82,11 @@ func (r Result[T]) Must(events ...func(e *zerolog.Event)) T {
 	return r.getValue()
 }
 
-func (r Result[T]) Catch(setter *error, ctx ...context.Context) bool {
+func (r Result[T]) CatchErr(setter *error, ctx ...context.Context) bool {
 	return catchErr(newError(r.err), nil, setter, ctx...)
 }
 
-func (r Result[T]) CatchErr(setter ErrSetter, ctx ...context.Context) bool {
+func (r Result[T]) Catch(setter ErrSetter, ctx ...context.Context) bool {
 	return catchErr(newError(r.err), setter, nil, ctx...)
 }
 
@@ -192,15 +192,15 @@ func (r Result[T]) WrapErr(err *errors.Err, tags ...errors.Tag) Result[T] {
 	return Result[T]{err: errors.WrapTag(errors.WrapCaller(err, 1), tags...)}
 }
 
-func (r Result[T]) Unwrap(setter *error, contexts ...context.Context) T {
+func (r Result[T]) UnwrapErr(setter *error, contexts ...context.Context) T {
 	ret, err := unwrapErr(r, setter, nil, contexts...)
 	if err != nil {
 		*setter = errors.WrapCaller(err, 1)
 	}
 	return ret
 }
 
-func (r Result[T]) UnwrapErr(setter ErrSetter, contexts ...context.Context) T {
+func (r Result[T]) Unwrap(setter ErrSetter, contexts ...context.Context) T {
 	ret, err := unwrapErr(r, nil, setter, contexts...)
 	if err != nil {
 		setError(setter, errors.WrapCaller(err, 1))
diff --git a/v2/result/result_test.go b/v2/result/result_test.go
@@ -47,17 +47,17 @@ func TestErrOf(t *testing.T) {
 	resultchecker.RegisterErrCheck(log.RecordErr())
 
 	var err result.Error
-	if fn1().CatchErr(&err, ctx) {
+	if fn1().Catch(&err, ctx) {
 		errors.Debug(err.GetErr())
 	}
 }
 
 func fn1() (r result.Result[string]) {
-	if fn3().CatchErr(&r) {
+	if fn3().Catch(&r) {
 		return
 	}
 
-	val := fn2().UnwrapErr(&r)
+	val := fn2().Unwrap(&r)
 	if r.IsErr() {
 		return
 	}
@@ -70,7 +70,7 @@ func fn2() (r result.Result[string]) {
 		InspectErr(func(err error) {
 			log.Err(err).Msg("test error")
 		}).
-		CatchErr(&r)
+		Catch(&r)
 	if r.IsErr() {
 		return
 	}

Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ func Key(key string) string {`
`120`	`120`
`121`	`121`	`func LoadFiles(files ...string) (r result.Error) {`
`122`	`122`	`files = lo.Filter(files, func(item string, index int) bool { return pathutil.IsExist(item) })`
`123`		`- if result.CatchErr(&r, godotenv.Load(files...)) {`
	`123`	`+ if result.Catch(&r, godotenv.Load(files...)) {`
`124`	`124`	`return`
`125`	`125`	`}`
`126`	`126`
Original file line number	Diff line number	Diff line change
`@@ -106,27 +106,25 @@ func WrapFn[T any](fn func() (T, error)) Result[T] {`
`106`	`106`	`return Result[T]{err: err}`
`107`	`107`	`}`
`108`	`108`
`109`		`-func CatchErr(setter ErrSetter, err error, contexts ...context.Context) bool {`
	`109`	`+func Catch(setter ErrSetter, err error, contexts ...context.Context) bool {`
`110`	`110`	`return catchErr(newError(err), setter, nil, contexts...)`
`111`	`111`	`}`
`112`	`112`
`113`		`-func Catch(rawSetter *error, err error, contexts ...context.Context) bool {`
	`113`	`+func CatchErr(rawSetter *error, err error, contexts ...context.Context) bool {`
`114`	`114`	`return catchErr(newError(err), nil, rawSetter, contexts...)`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`func MapTo[T, U any](r Result[T], fn func(T) U) Result[U] {`
`118`	`118`	`if r.IsErr() {`
`119`		`- err := errors.WrapCaller(r.getErr(), 1)`
`120`		`- return Fail[U](err)`
	`119`	`+ return Fail[U](errors.WrapCaller(r.getErr(), 1))`
`121`	`120`	`}`
`122`	`121`
`123`	`122`	`return OK(fn(r.getValue()))`
`124`	`123`	`}`
`125`	`124`
`126`	`125`	`func FlatMapTo[T, U any](r Result[T], fn func(T) Result[U]) Result[U] {`
`127`	`126`	`if r.IsErr() {`
`128`		`- err := errors.WrapCaller(r.getErr(), 1)`
`129`		`- return Fail[U](err)`
	`127`	`+ return Fail[U](errors.WrapCaller(r.getErr(), 1))`
`130`	`128`	`}`
`131`	`129`
`132`	`130`	`return fn(r.getValue())`
Original file line number	Diff line number	Diff line change
`@@ -82,11 +82,11 @@ func (r Result[T]) Must(events ...func(e *zerolog.Event)) T {`
`82`	`82`	`return r.getValue()`
`83`	`83`	`}`
`84`	`84`
`85`		`-func (r Result[T]) Catch(setter *error, ctx ...context.Context) bool {`
	`85`	`+func (r Result[T]) CatchErr(setter *error, ctx ...context.Context) bool {`
`86`	`86`	`return catchErr(newError(r.err), nil, setter, ctx...)`
`87`	`87`	`}`
`88`	`88`
`89`		`-func (r Result[T]) CatchErr(setter ErrSetter, ctx ...context.Context) bool {`
	`89`	`+func (r Result[T]) Catch(setter ErrSetter, ctx ...context.Context) bool {`
`90`	`90`	`return catchErr(newError(r.err), setter, nil, ctx...)`
`91`	`91`	`}`
`92`	`92`
`@@ -192,15 +192,15 @@ func (r Result[T]) WrapErr(err *errors.Err, tags ...errors.Tag) Result[T] {`
`192`	`192`	`return Result[T]{err: errors.WrapTag(errors.WrapCaller(err, 1), tags...)}`
`193`	`193`	`}`
`194`	`194`
`195`		`-func (r Result[T]) Unwrap(setter *error, contexts ...context.Context) T {`
	`195`	`+func (r Result[T]) UnwrapErr(setter *error, contexts ...context.Context) T {`
`196`	`196`	`ret, err := unwrapErr(r, setter, nil, contexts...)`
`197`	`197`	`if err != nil {`
`198`	`198`	`*setter = errors.WrapCaller(err, 1)`
`199`	`199`	`}`
`200`	`200`	`return ret`
`201`	`201`	`}`
`202`	`202`
`203`		`-func (r Result[T]) UnwrapErr(setter ErrSetter, contexts ...context.Context) T {`
	`203`	`+func (r Result[T]) Unwrap(setter ErrSetter, contexts ...context.Context) T {`
`204`	`204`	`ret, err := unwrapErr(r, nil, setter, contexts...)`
`205`	`205`	`if err != nil {`
`206`	`206`	`setError(setter, errors.WrapCaller(err, 1))`
Original file line number	Diff line number	Diff line change
`@@ -47,17 +47,17 @@ func TestErrOf(t *testing.T) {`
`47`	`47`	`resultchecker.RegisterErrCheck(log.RecordErr())`
`48`	`48`
`49`	`49`	`var err result.Error`
`50`		`- if fn1().CatchErr(&err, ctx) {`
	`50`	`+ if fn1().Catch(&err, ctx) {`
`51`	`51`	`errors.Debug(err.GetErr())`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`func fn1() (r result.Result[string]) {`
`56`		`- if fn3().CatchErr(&r) {`
	`56`	`+ if fn3().Catch(&r) {`
`57`	`57`	`return`
`58`	`58`	`}`
`59`	`59`
`60`		`- val := fn2().UnwrapErr(&r)`
	`60`	`+ val := fn2().Unwrap(&r)`
`61`	`61`	`if r.IsErr() {`
`62`	`62`	`return`
`63`	`63`	`}`
`@@ -70,7 +70,7 @@ func fn2() (r result.Result[string]) {`
`70`	`70`	`InspectErr(func(err error) {`
`71`	`71`	`log.Err(err).Msg("test error")`
`72`	`72`	`}).`
`73`		`- CatchErr(&r)`
	`73`	`+ Catch(&r)`
`74`	`74`	`if r.IsErr() {`
`75`	`75`	`return`
`76`	`76`	`}`