feat std log (#4)

assert/assert_test.go

@@ -2,14 +2,15 @@ package assert
 
 import (
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestCheckNil(t *testing.T) {
+	var is = assert.New(t)
 	var a *int
-	Assert(a == nil, "ok")
-}
 
-func try(fn func()) (err error) {
-	fn()
-	return nil
+	is.Panics(func() {
+		Assert(a == nil, "ok")
+	})
 }

assert/must.go

@@ -6,42 +6,56 @@ import (
 	"runtime/debug"
 
 	"github.com/pubgo/funk/errors"
+	"github.com/pubgo/funk/generic"
+	"github.com/pubgo/funk/try"
 )
 
 func Must(err error, args ...interface{}) {
-	if errors.IsNil(err) {
+	if generic.IsNil(err) {
 		return
 	}
 
 	panic(errors.WrapCaller(errors.Wrap(err, fmt.Sprint(args...))))
 }
 
-func Expect(err error, msg string, args ...interface{}) {
-	if errors.IsNil(err) {
+func MustFn(errFn func() error, args ...interface{}) {
+	var err = try.Try(errFn)
+	if generic.IsNil(err) {
 		return
 	}
 
-	panic(errors.WrapCaller(errors.Wrap(err, fmt.Sprintf(msg, args...))))
+	panic(errors.WrapCaller(errors.Wrap(err, fmt.Sprint(args...))))
 }
 
 func MustF(err error, msg string, args ...interface{}) {
-	if errors.IsNil(err) {
+	if generic.IsNil(err) {
 		return
 	}
 
 	panic(errors.WrapCaller(errors.Wrap(err, fmt.Sprintf(msg, args...))))
 }
 
 func Must1[T any](ret T, err error) T {
-	if !errors.IsNil(err) {
+	if !generic.IsNil(err) {
 		panic(errors.WrapCaller(err))
 	}
 
 	return ret
 }
 
 func Exit(err error, args ...interface{}) {
-	if errors.IsNil(err) {
+	if generic.IsNil(err) {
+		return
+	}
+
+	errors.Debug(errors.WrapCaller(errors.Wrap(err, fmt.Sprint(args...))))
+	debug.PrintStack()
+	os.Exit(1)
+}
+
+func ExitFn(errFn func() error, args ...interface{}) {
+	var err = try.Try(errFn)
+	if generic.IsNil(err) {
 		return
 	}
 
@@ -51,7 +65,7 @@ func Exit(err error, args ...interface{}) {
 }
 
 func ExitF(err error, msg string, args ...interface{}) {
-	if errors.IsNil(err) {
+	if generic.IsNil(err) {
 		return
 	}
 
@@ -61,7 +75,7 @@ func ExitF(err error, msg string, args ...interface{}) {
 }
 
 func Exit1[T any](ret T, err error) T {
-	if !errors.IsNil(err) {
+	if !generic.IsNil(err) {
 		errors.Debug(errors.WrapCaller(err))
 		debug.PrintStack()
 		os.Exit(1)

async/go.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/pubgo/funk/assert"
 	"github.com/pubgo/funk/errors"
+	"github.com/pubgo/funk/generic"
 	"github.com/pubgo/funk/pretty"
 	"github.com/pubgo/funk/recovery"
 	"github.com/pubgo/funk/stack"
@@ -18,8 +19,8 @@ func Async[T any](fn func() (T, error)) *Future[T] {
 
 	var f = newFuture[T]()
 	go func() {
-		defer recovery.Recovery(func(err errors.XError) {
-			err.AddTag("fn_stack", stack.CallerWithFunc(fn).String())
+		defer recovery.Recovery(func(err error) {
+			err = errors.WrapKV(err, "fn_stack", stack.CallerWithFunc(fn).String())
 			f.setErr(err)
 		})
 
@@ -39,7 +40,7 @@ func GoSafe(fn func() error, cb ...func(err error)) {
 
 	go func() {
 		err := try.Try(fn)
-		if errors.IsNil(err) {
+		if generic.IsNil(err) {
 			return
 		}
 
@@ -103,7 +104,7 @@ func Timeout(dur time.Duration, fn func() error) (gErr error) {
 }
 
 func logErr(fn interface{}, err error) {
-	if errors.IsNil(err) {
+	if generic.IsNil(err) {
 		return
 	}
 

async/go_test.go

@@ -20,21 +20,21 @@ func TestYield(t *testing.T) {
 			yield(time.Now().String())
 			yield(time.Now().String())
 			panic("d")
-		}).Chan())
+		}).ToList())
 
 		t.Log(Yield(func(yield func(string)) error {
 			yield(time.Now().String())
 			yield(time.Now().String())
 			yield(time.Now().String())
 			return fmt.Errorf("err test")
-		}).Chan())
+		}).ToList())
 
 		t.Log(Yield(func(yield func(string)) error {
 			yield(time.Now().String())
 			yield(time.Now().String())
 			yield(time.Now().String())
 			return nil
-		}).Chan())
+		}).ToList())
 	})
 }
 

async/iterator.go

@@ -3,11 +3,11 @@ package async
 import "github.com/pubgo/funk/result"
 
 func iteratorOf[T any]() *Iterator[T] {
-	return &Iterator[T]{v: make(chan result.Result[T])}
+	return &Iterator[T]{v: make(chan T)}
 }
 
 type Iterator[T any] struct {
-	v    chan result.Result[T]
+	v    chan T
 	done chan struct{}
 	err  error
 }
@@ -25,20 +25,34 @@ func (cc *Iterator[T]) setErr(err error) {
 }
 
 func (cc *Iterator[T]) setValue(v T) {
-	cc.v <- result.OK(v)
+	cc.v <- v
 }
 
-func (cc *Iterator[T]) Next() (result.Result[T], bool) {
+func (cc *Iterator[T]) Next() (T, bool) {
 	r, ok := <-cc.v
 	return r, ok
 }
 
-func (cc *Iterator[T]) Range(fn func(r result.Result[T])) {
+func (cc *Iterator[T]) Range(fn func(r T)) error {
 	for c := range cc.v {
+		if cc.err != nil {
+			return cc.err
+		}
+
 		fn(c)
 	}
+	return nil
 }
 
-func (cc *Iterator[T]) Chan() <-chan result.Result[T] {
-	return cc.v
+func (cc *Iterator[T]) ToList() result.Result[[]T] {
+	var ret result.Result[[]T]
+	if cc.err != nil {
+		return ret.WithErr(cc.err)
+	}
+
+	var ll []T
+	for c := range cc.v {
+		ll = append(ll, c)
+	}
+	return ret
 }

async/iterator_test.go

@@ -0,0 +1,22 @@
+package async
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestName(t *testing.T) {
+	var ch = make(chan string, 10)
+	ch <- "hello"
+	ch <- "hello"
+	ch <- "hello"
+	ch <- "hello"
+	close(ch)
+	for {
+		mm, ok := <-ch
+		fmt.Println(mm, ok)
+		if !ok {
+			break
+		}
+	}
+}

async/promise.go

@@ -14,8 +14,8 @@ func Promise[T any](fn func(resolve func(T), reject func(err error))) *Future[T]
 
 	var f = newFuture[T]()
 	go func() {
-		defer recovery.Recovery(func(err errors.XError) {
-			err.AddTag("fn", stack.CallerWithFunc(fn).String())
+		defer recovery.Recovery(func(err error) {
+			err = errors.WrapKV(err, "fn", stack.CallerWithFunc(fn).String())
 			f.setErr(err)
 		})
 
@@ -36,8 +36,8 @@ func Group[T any](do func(async func(func() (T, error))) error) *Iterator[T] {
 			wg.Add(1)
 			go func() {
 				defer wg.Done()
-				defer recovery.Recovery(func(err errors.XError) {
-					err.AddTag("fn_stack", stack.CallerWithFunc(do).String())
+				defer recovery.Recovery(func(err error) {
+					err = errors.WrapKV(err, "fn_stack", stack.CallerWithFunc(do).String())
 					rr.setErr(err)
 				})
 
@@ -58,8 +58,8 @@ func Yield[T any](do func(yield func(T)) error) *Iterator[T] {
 	var dd = iteratorOf[T]()
 	go func() {
 		defer dd.setDone()
-		defer recovery.Recovery(func(err errors.XError) {
-			err.AddTag("fn_stack", stack.CallerWithFunc(do).String())
+		defer recovery.Recovery(func(err error) {
+			err = errors.WrapKV(err, "fn_stack", stack.CallerWithFunc(do).String())
 			dd.setErr(err)
 		})
 

clients/bbolt/client.go

@@ -0,0 +1,88 @@
+package bbolt
+
+import (
+	"context"
+
+	"github.com/opentracing/opentracing-go/ext"
+	"github.com/pubgo/funk/assert"
+	"github.com/pubgo/funk/log"
+	"github.com/pubgo/funk/log/logutil"
+	"github.com/pubgo/funk/merge"
+	"github.com/pubgo/funk/result"
+	"github.com/pubgo/funk/strutil"
+	"github.com/pubgo/funk/tracing"
+	bolt "go.etcd.io/bbolt"
+)
+
+func New(cfg *Config, log log.Logger) *Client {
+	cfg = merge.Copy(DefaultConfig(), cfg).Unwrap()
+	assert.MustF(cfg.Build(), "build failed, cfg=%#v", cfg)
+
+	return &Client{DB: cfg.Get(), log: log}
+}
+
+type Client struct {
+	*bolt.DB
+	log log.Logger
+}
+
+func (t *Client) bucket(name string, tx *bolt.Tx) *bolt.Bucket {
+	var _, err = tx.CreateBucketIfNotExists([]byte(name))
+	logutil.ErrRecord(t.log, err, func(evt *log.Event) string {
+		evt.Str("bucket_name", name)
+		return "failed to create bucket"
+	})
+	return tx.Bucket([]byte(name))
+}
+
+func (t *Client) Set(ctx context.Context, key string, val []byte, names ...string) error {
+	return t.Update(ctx, func(bucket *bolt.Bucket) error {
+		return bucket.Put([]byte(key), val)
+	}, names...)
+}
+
+func (t *Client) Get(ctx context.Context, key string, names ...string) result.Result[[]byte] {
+	var (
+		val []byte
+		err = t.View(ctx, func(bucket *bolt.Bucket) error {
+			val = bucket.Get([]byte(key))
+			return nil
+		}, names...)
+	)
+
+	return result.Wrap(val, err)
+}
+
+func (t *Client) List(ctx context.Context, fn func(k, v []byte) error, names ...string) error {
+	return t.View(ctx, func(bucket *bolt.Bucket) error { return bucket.ForEach(fn) }, names...)
+}
+
+func (t *Client) Delete(ctx context.Context, key string, names ...string) error {
+	return t.Update(ctx, func(bucket *bolt.Bucket) error {
+		return bucket.Delete([]byte(key))
+	}, names...)
+}
+
+func (t *Client) View(ctx context.Context, fn func(*bolt.Bucket) error, names ...string) error {
+	name := strutil.GetDefault(names...)
+
+	var span = tracing.CreateChild(ctx, name)
+	defer span.Finish()
+	ext.DBType.Set(span, Name)
+
+	return t.DB.View(func(tx *bolt.Tx) error {
+		return fn(t.bucket(name, tx))
+	})
+}
+
+func (t *Client) Update(ctx context.Context, fn func(*bolt.Bucket) error, names ...string) error {
+	name := strutil.GetDefault(names...)
+
+	var span = tracing.CreateChild(ctx, name)
+	defer span.Finish()
+	ext.DBType.Set(span, Name)
+
+	return t.DB.Update(func(tx *bolt.Tx) (err error) {
+		return fn(t.bucket(name, tx))
+	})
+}