fix: barry quick fix, 2025-09-12 23:58:36

Author: kooksee

assert/assert.go

@@ -2,16 +2,25 @@ package assert
 
 import (
 	"fmt"
-)
 
-var EnablePrintStack bool
+	"github.com/google/go-cmp/cmp"
+	"github.com/k0kubun/pp/v3"
+)
 
 func Assert(b bool, format string, a ...interface{}) {
 	if b {
 		must(fmt.Errorf(format, a...))
 	}
 }
 
+func MustEqual[T any](a, b T) {
+	if !cmp.Equal(a, b) {
+		pp.Println("a: ", a)
+		pp.Println("b: ", b)
+		must(fmt.Errorf("a,b not equal"))
+	}
+}
+
 func If(b bool, format string, a ...interface{}) {
 	if b {
 		must(fmt.Errorf(format, a...))

assert/assert_test.go

@@ -7,10 +7,6 @@ import (
 	"github.com/pubgo/funk/recovery"
 )
 
-func init() {
-	assert.EnablePrintStack = true
-}
-
 func TestCheckNil(t *testing.T) {
 	var a *int
 

assert/util.go

@@ -3,9 +3,10 @@ package assert
 import (
 	"fmt"
 	"log/slog"
+	"reflect"
 	"runtime/debug"
 
-	"github.com/pubgo/funk/stack"
+	"github.com/k0kubun/pp/v3"
 )
 
 func messageFromMsgAndArgs(msgAndArgs ...any) string {
@@ -17,10 +18,9 @@ func messageFromMsgAndArgs(msgAndArgs ...any) string {
 		if msgAsStr, ok := msgAndArgs[0].(string); ok {
 			return msgAsStr
 		}
-		return fmt.Sprintf("%+v", msgAndArgs[0])
 	}
 
-	return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
+	return pp.Sprint(msgAndArgs...)
 }
 
 func must(err error, messageArgs ...any) {
@@ -32,15 +32,12 @@ func must(err error, messageArgs ...any) {
 	if message == "" {
 		message = err.Error()
 	} else {
-		message = fmt.Sprintf("msg:%s err:%s", message, err.Error())
+		message = fmt.Sprintf("msg:%v err:%s", message, err.Error())
 	}
 
-	if EnablePrintStack {
-		slog.Error(message)
-		debug.PrintStack()
-	}
-
-	panic(message)
+	slog.Error(message)
+	debug.PrintStack()
+	panic(err)
 }
 
 func try(fn func() error) (gErr error) {
@@ -51,7 +48,7 @@ func try(fn func() error) (gErr error) {
 
 	defer func() {
 		if gErr != nil {
-			gErr = fmt.Errorf("stack:%s, err:%w", stack.CallerWithFunc(fn).String(), gErr)
+			gErr = fmt.Errorf("stack:%s, err:%w", reflect.TypeOf(fn).String(), gErr)
 		}
 	}()
 

config/config.go

@@ -36,11 +36,13 @@ var (
 )
 
 func init() {
-	vars.RegisterValue("config", map[string]any{
-		"config_type": defaultConfigType,
-		"config_name": defaultConfigName,
-		"config_path": configPath,
-		"config_dir":  configDir,
+	vars.Register("config", func() any {
+		return map[string]any{
+			"config_type": defaultConfigType,
+			"config_name": defaultConfigName,
+			"config_path": configPath,
+			"config_dir":  configDir,
+		}
 	})
 }
 

errors/errinter/color_name.go

@@ -0,0 +1,36 @@
+package errinter
+
+import (
+	"strings"
+
+	"github.com/pubgo/funk/internal/color"
+)
+
+var width = 11
+
+func getColorErrField(name string) string {
+	if width-len(name) < 0 {
+		return name
+	}
+	return strings.Repeat(" ", width-len(name)) + name
+}
+
+var (
+	ColorKind       = color.Green.Str(getColorErrField("kind"))
+	ColorMsg        = color.Green.Str(getColorErrField("msg"))
+	ColorService    = color.Green.Str(getColorErrField("service"))
+	ColorOperation  = color.Green.Str(getColorErrField("operation"))
+	ColorId         = color.Green.Str(getColorErrField("id"))
+	ColorDetail     = color.Green.Str(getColorErrField("detail"))
+	ColorTags       = color.Green.Str(getColorErrField("tags"))
+	ColorErrMsg     = color.Red.Str(getColorErrField("err_msg"))
+	ColorErrDetail  = color.Red.Str(getColorErrField("err_detail"))
+	ColorCaller     = color.Green.Str(getColorErrField("caller"))
+	ColorCode       = color.Green.Str(getColorErrField("code"))
+	ColorMessage    = color.Green.Str(getColorErrField("message"))
+	ColorBiz        = color.Green.Str(getColorErrField("biz_code"))
+	ColorStatusCode = color.Green.Str(getColorErrField("status_code"))
+	ColorName       = color.Green.Str(getColorErrField("name"))
+	ColorStack      = color.Green.Str(getColorErrField("stack"))
+	ColorVersion    = color.Green.Str(getColorErrField("version"))
+)

errors/errinter/colorfield.go

@@ -5,10 +5,10 @@ import (
 	"errors"
 	"fmt"
 	"os"
-	"strings"
 	"sync"
 
 	"github.com/k0kubun/pp/v3"
+	"github.com/rs/xid"
 	"github.com/rs/zerolog/log"
 	"github.com/samber/lo"
 	"google.golang.org/protobuf/encoding/prototext"
@@ -18,7 +18,6 @@ import (
 
 	"github.com/pubgo/funk"
 	"github.com/pubgo/funk/log/logutil"
-	"github.com/pubgo/funk/pretty"
 	"github.com/pubgo/funk/proto/errorpb"
 )
 
@@ -36,38 +35,19 @@ func ParseError(val interface{}) error {
 		return errors.New(v)
 	case []byte:
 		return errors.New(string(v))
+	case proto.Message:
+		return errors.New(prototext.Format(v))
 	default:
-		return errors.New(SimplePrint(v))
+		return errors.New(errPretty().Sprint(v))
 	}
 }
 
-var Simple = sync.OnceValue(func() *pp.PrettyPrinter {
-	printer := pp.New()
-	printer.SetColoringEnabled(false)
-	printer.SetExportedOnly(false)
-	printer.SetOmitEmpty(true)
-	printer.SetMaxDepth(3)
-	return printer
-})
-
-func SimplePrint(v interface{}) string {
-	return strings.ReplaceAll(Simple().Sprint(v), "\n", "")
-}
-
 func GetErrorId(err error) string {
-	if err == nil {
-		return ""
-	}
-
-	for err != nil {
-		if v, ok := err.(Error); ok {
-			return v.ID()
-		}
-
-		err = Unwrap(err)
+	if v, ok := lo.ErrorsAs[Error](err); ok && v != nil {
+		return v.ID()
 	}
 
-	return ""
+	return xid.New().String()
 }
 
 func Unwrap(err error) error {
@@ -103,8 +83,7 @@ func Debug(err error) {
 		return
 	}
 
-	pretty.SetDefaultMaxDepth(20)
-	pretty.Println(err)
+	Console().Println(err)
 }
 
 func MustTagsToAny(tags ...*errorpb.Tag) []*anypb.Any {
@@ -171,3 +150,21 @@ func MustProtoToAny(p proto.Message) *anypb.Any {
 
 	return pb
 }
+
+var errPretty = sync.OnceValue(func() *pp.PrettyPrinter {
+	printer := pp.New()
+	printer.SetColoringEnabled(false)
+	printer.SetExportedOnly(false)
+	printer.SetOmitEmpty(true)
+	printer.SetMaxDepth(3)
+	return printer
+})
+
+var Console = sync.OnceValue(func() *pp.PrettyPrinter {
+	printer := pp.New()
+	printer.SetColoringEnabled(true)
+	printer.SetExportedOnly(false)
+	printer.SetOmitEmpty(true)
+	printer.SetMaxDepth(5)
+	return printer
+})

errors/errinter/utils.go

@@ -0,0 +1,41 @@
+package errinter_test
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"google.golang.org/protobuf/encoding/prototext"
+
+	"github.com/pubgo/funk/errors"
+	"github.com/pubgo/funk/errors/errinter"
+	"github.com/pubgo/funk/proto/errorpb"
+)
+
+func TestGetErrorId(t *testing.T) {
+	err := errors.New("test error id")
+	pbTxt := prototext.Format(errinter.ParseErrToPb(err))
+	errId := errinter.GetErrorId(err)
+	assert.NotEmpty(t, errId)
+	assert.Contains(t, pbTxt, errId)
+}
+
+func TestParseError(t *testing.T) {
+	assert.Equal(t, errinter.ParseError(nil), nil)
+	assert.Equal(t, errinter.ParseError("hello").Error(), "hello")
+	assert.Equal(t, errinter.ParseError(fmt.Errorf("err test")).Error(), "err test")
+
+	errMsg := errinter.ParseError(prototext.Format(errinter.MustProtoToAny(&errorpb.ErrMsg{Msg: "test msg error"}))).Error()
+	assert.Equal(t,
+		strings.ReplaceAll(errMsg, "  ", " "),
+		"[type.googleapis.com/errors.ErrMsg]: {\n msg: \"test msg error\"\n}\n",
+	)
+
+	ctx := context.WithValue(context.Background(), "hello", "world")
+	assert.Equal(t,
+		errinter.ParseError(ctx).Error(),
+		"&context.valueCtx{\n  Context: context.backgroundCtx{},\n  key:     \"hello\",\n  val:     \"world\",\n}",
+	)
+}

errors/errinter/z_util_test.go

@@ -73,26 +73,7 @@ func UnwrapEach(err error, call func(e error) bool) {
 
 func AsA[T any](err error) (*T, bool) {
 	var target T
-	val := reflect.ValueOf(&target)
-	typ := val.Type()
-	if typ.Kind() != reflect.Ptr || val.IsNil() {
-		panic("errors: target must be a non-nil pointer")
-	}
-
-	targetType := typ.Elem()
-	for err != nil {
-		if reflect.TypeOf(err).AssignableTo(targetType) {
-			val.Elem().Set(reflect.ValueOf(err))
-			return &target, true
-		}
-
-		if x, ok := err.(ErrAs); ok && x.As(&target) {
-			return &target, true
-		}
-
-		err = Unwrap(err)
-	}
-	return &target, false
+	return &target, As(err, &target)
 }
 
 func As(err error, target any) bool {

errors/errors.go

@@ -165,10 +165,6 @@ func IsNil(err interface{}) bool {
 	}
 
 	v := reflect.ValueOf(err)
-	if !v.IsValid() {
-		return true
-	}
-
 	switch v.Kind() {
 	case reflect.Chan, reflect.Func, reflect.Map, reflect.Pointer, reflect.UnsafePointer, reflect.Slice, reflect.Interface:
 		return v.IsNil()