fix: 完善文档

Author: kooksee

README.md

@@ -1,6 +1,11 @@
 # xerror
 
-go error 简单实现
+> go error 简单实现
+
+1. 高效处理golang的error, 避免处理大量的 `err!=nil` 判断
+2. 高效处理golang的recover, 让错误中包含丰富的堆栈信息
+3. xerror实现标准As,Is,Unwrap接口, 可以和其他error库一起使用
+4. 简单易用
 
 
 ## 性能分析
@@ -22,105 +27,51 @@ ok      github.com/pubgo/xerror 4.363s
 ```
 
 ## example
-```go
-package xerror_http
-
-import (
-	"github.com/pubgo/xerror"
-	"net/http"
-)
-
-var (
-	ErrHttp                = xerror.New("http error", "http错误")
-	ErrBadRequest          = ErrHttp.New("400", http.StatusText(400))
-	ErrUnauthorized        = ErrHttp.New("401", http.StatusText(401))
-	ErrForbidden           = ErrHttp.New("403", http.StatusText(403))
-	ErrNotFound            = ErrHttp.New("404", http.StatusText(404))
-	ErrMethodNotAllowed    = ErrHttp.New("405", http.StatusText(405))
-	ErrTimeout             = ErrHttp.New("408", http.StatusText(408))
-	ErrConflict            = ErrHttp.New("409", http.StatusText(409))
-	ErrInternalServerError = ErrHttp.New("500", http.StatusText(500))
-)
-```
-
 ```go
 package xerror_test
 
 import (
 	"fmt"
-	"log"
 	"testing"
 
 	"github.com/pubgo/xerror"
-	"github.com/pubgo/xerror/xerror_core"
-	"github.com/pubgo/xerror/xerror_http"
 )
 
-func check(b bool) {
-	if !b {
-		log.Fatalln("")
-	}
-}
-
-func panic1(a ...interface{}) (err error) {
-	defer xerror.RespErr(&err)
-	xerror.PanicF(xerror_http.ErrBadRequest, "panic1 %+v", a)
-	return
-}
-
-func panic2(a ...interface{}) (err error) {
-	defer xerror.RespErr(&err)
-	xerror.PanicF(panic1(a...), "panic2 %+v", a)
-	return
-}
-
-func panicWrap(a ...interface{}) (err error) {
-	return xerror.WrapF(panic2(a...), "panicWrap %+v", a)
+func TestErr(t *testing.T) {
+	fmt.Println(xerror.Wrap(xerror.ErrAssert))
 }
 
-func TestStack(t *testing.T) {
-	defer xerror.Resp(func(err xerror.XErr) {
-		fmt.Println(err.Stack(true))
+func TestParseWith(t *testing.T) {
+	var err = fmt.Errorf("hello error")
+	xerror.ParseWith(err, func(err xerror.XErr) {
+		fmt.Printf("%v\n", err)
 	})
-	xerror.Panic(panicWrap(1, 2, 4, 5))
 }
 
-func TestAs(t *testing.T) {
-	check(xerror.FamilyAs(panicWrap(1, 2, 4, 5), xerror_http.ErrHttp) == true)
-	check(xerror.FamilyAs(panicWrap(1, 2, 4, 5), xerror_http.ErrBadRequest) == true)
-	check(xerror.FamilyAs(panicWrap(1, 2, 4, 5), xerror_http.ErrNotFound) == false)
+func TestRespTest(t *testing.T) {
+	defer xerror.RespTest(t)
+	TestPanic1(t)
 }
 
-func TestExit(t *testing.T) {
-	xerror_core.PrintStack = false
-	xerror.Exit(panicWrap(1, 2, 4, 5))
+func TestRespNext(t *testing.T) {
+	defer xerror.RespExit("TestRespNext")
+	TestPanic1(t)
 }
 
-func TestTry(t *testing.T) {
-	fmt.Println(xerror.Try(func() {
-		panic("hello")
-	}))
-}
+func TestPanic1(t *testing.T) {
+	//defer xerror.RespExit()
+	defer xerror.RespRaise(func(err xerror.XErr) error {
+		return xerror.WrapF(err, "test raise")
+	})
 
-func BenchmarkPanic(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		_ = func() (err error) {
-			defer xerror.RespErr(&err)
-			xerror.Panic(xerror_http.ErrBadRequest)
-			return
-		}()
-	}
+	//xerror.Panic(xerror.New("ok"))
+	xerror.Panic(fmt.Errorf("ss"))
 }
 
-func BenchmarkPanicWithoutCaller(b *testing.B) {
-	xerror_core.IsCaller = false
-	for i := 0; i < b.N; i++ {
-		_ = func() (err error) {
-			defer xerror.RespErr(&err)
-			xerror.Panic(xerror_http.ErrBadRequest)
-			return
-		}()
-	}
+func init1Next() (err error) {
+	defer xerror.RespErr(&err)
+	xerror.Panic(fmt.Errorf("test next"))
+	return nil
 }
 
 func BenchmarkNoPanic(b *testing.B) {

example/main.go

@@ -9,7 +9,9 @@ import (
 
 func main() {
 	xerror.Exit(http.ListenAndServe(":8088", http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
-		defer xerror.RespHttp(writer, request)
+		defer xerror.RespHttp(writer, request, func(err error) {
+			fmt.Println(err)
+		})
 		xerror.Panic(fmt.Errorf("panic"))
 	})))
 }

internal/utils/util.go

@@ -25,6 +25,7 @@ func CallerWithDepth(cd int) string {
 		return "unknown type"
 	}
 
+
 	file, line := fn.FileLine(f.pc())
 	return file + ":" + strconv.Itoa(line)
 }

xerror.go

@@ -66,13 +66,13 @@ func (t *xerror) Is(err error) bool {
 		return false
 	}
 
-	switch err := err.(type) {
+	switch _err := err.(type) {
 	case *xerrorBase:
-		return err == t.Err
+		return _err == t.Err
 	case *xerror:
-		return err == t || err.Err == t.Err
+		return _err == t || _err.Err == t.Err
 	case error:
-		return t.Err == err
+		return t.Err == _err
 	default:
 		return false
 	}

xerror_goleak/goleak.go

@@ -1,9 +1,9 @@
 package xerror_goleak
 
 import (
-	"go.uber.org/goleak"
-
 	"testing"
+
+	"go.uber.org/goleak"
 )
 
 type Option = goleak.Option

xerror_resp.go

@@ -133,7 +133,7 @@ func RespTest(t *testing.T, debugs ...bool) {
 	t.Fatal(msg)
 }
 
-func RespHttp(w http.ResponseWriter, req *http.Request) {
+func RespHttp(w http.ResponseWriter, req *http.Request, fns ...func(err error)) {
 	val := recover()
 	if val == nil {
 		return
@@ -156,5 +156,9 @@ func RespHttp(w http.ResponseWriter, req *http.Request) {
 	fmt.Fprint(w, "\n\n\n\n")
 	fmt.Fprintln(w, "stack")
 	buf := make([]byte, 1024*1024)
+	if len(fns) > 0 {
+		fns[0](err)
+	}
+
 	fmt.Fprintln(w, string(buf[:runtime.Stack(buf, true)]))
 }