Merge pull request #2 from goinsane/develop

v1.0.0

Author: orkunkaraduman

README.md

@@ -4,4 +4,4 @@
 
 Package erf provides error management with stack trace.
 Erf is an error type that wraps the underlying error that stores and formats the stack trace.
-Please see [godoc](https://pkg.go.dev/github.com/goinsane/erf) and [example](https://github.com/goinsane/erf/tree/master/example).
+Please see [godoc](https://pkg.go.dev/github.com/goinsane/erf) and [examples](https://github.com/goinsane/erf/tree/master/examples).

erf.go

@@ -5,9 +5,15 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"strings"
 	"unsafe"
 )
 
+var (
+	// DefaultPCSize defines max length of Erf program counters in PC() method.
+	DefaultPCSize = int(4096 / unsafe.Sizeof(uintptr(0)))
+)
+
 // Erf is an error type that wraps the underlying error that stores and formats the stack trace.
 type Erf struct {
 	err        error
@@ -35,46 +41,60 @@ func (e *Erf) Format(f fmt.State, verb rune) {
 	buf := bytes.NewBuffer(nil)
 	switch verb {
 	case 's', 'v':
-		buf.WriteString(e.err.Error())
-		if f.Flag('+') {
-			format := "%+"
-			for _, r := range []rune{'-', '#'} {
-				if f.Flag(int(r)) {
-					format += string(r)
-				}
-			}
-			wid, prec := 1, 1
-			if f.Flag('-') {
-				wid, prec = 2, 2
-			}
-			if w, ok := f.Width(); ok {
-				wid = w
-			}
-			if p, ok := f.Precision(); ok {
-				prec = p
+		if !f.Flag('+') {
+			buf.WriteString(e.err.Error())
+			break
+		}
+		format := "%+"
+		for _, r := range []rune{'-', '#'} {
+			if f.Flag(int(r)) {
+				format += string(r)
 			}
-			format += fmt.Sprintf("%d.%d", wid, prec)
-			format += "s"
-			buf.WriteRune('\n')
-			buf.WriteString(fmt.Sprintf(format, e.StackTrace()))
+		}
+		pad, wid, prec := byte('\t'), 0, 1
+		if f.Flag('-') {
+			pad = ' '
+			prec = 2
+		}
+		if w, ok := f.Width(); ok {
+			wid = w
+		}
+		if p, ok := f.Precision(); ok {
+			prec = p
+		}
+		format += fmt.Sprintf("%d.%d", wid, prec)
+		format += "s"
+		padding := bytes.Repeat([]byte{pad}, wid)
+		indent := bytes.Repeat([]byte{pad}, prec)
+		for _, line := range strings.Split(e.err.Error(), "\n") {
+			buf.Write(padding)
+			buf.Write(indent)
+			buf.WriteString(line)
 			buf.WriteRune('\n')
-			if !f.Flag('0') {
-				for err := e.Unwrap(); err != nil; {
-					if e2, ok := err.(*Erf); ok {
-						buf.WriteRune('\n')
-						buf.WriteString(e2.Error())
-						buf.WriteRune('\n')
-						buf.WriteString(fmt.Sprintf(format, e2.StackTrace()))
+		}
+		buf.WriteString(fmt.Sprintf(format, e.StackTrace()))
+		buf.WriteRune('\n')
+		if !f.Flag('0') {
+			for err := e.Unwrap(); err != nil; {
+				if e2, ok := err.(*Erf); ok {
+					buf.WriteRune('\n')
+					for _, line := range strings.Split(e2.err.Error(), "\n") {
+						buf.Write(padding)
+						buf.Write(indent)
+						buf.WriteString(line)
 						buf.WriteRune('\n')
 					}
-					if wErr, ok := err.(WrappedError); ok {
-						err = wErr.Unwrap()
-					} else {
-						err = nil
-					}
+					buf.WriteString(fmt.Sprintf(format, e2.StackTrace()))
+					buf.WriteRune('\n')
+				}
+				if wErr, ok := err.(WrappedError); ok {
+					err = wErr.Unwrap()
+				} else {
+					err = nil
 				}
 			}
 		}
+		buf.WriteRune('\n')
 	}
 	if buf.Len() > 0 {
 		_, _ = f.Write(buf.Bytes())
@@ -94,7 +114,7 @@ func (e *Erf) Len() int {
 // Arg returns an argument value on the given index. It panics if index is out of range.
 func (e *Erf) Arg(index int) interface{} {
 	if index < 0 || index >= e.Len() {
-		panic("index is out of range")
+		panic("index out of range")
 	}
 	return e.args[index]
 }
@@ -122,8 +142,11 @@ func (e *Erf) Attach(tags ...string) *Erf {
 	}
 	tagIndexes := make(map[string]int, len(tags))
 	for index, tag := range tags {
+		if tag == "" {
+			continue
+		}
 		if _, ok := tagIndexes[tag]; ok {
-			panic("tag is already defined")
+			panic("tag already defined")
 		}
 		tagIndexes[tag] = index
 	}
@@ -138,7 +161,7 @@ func (e *Erf) Tag(tag string) interface{} {
 		index = idx
 	}
 	if index < 0 || index >= e.Len() {
-		panic("tag is not found")
+		panic("tag not found")
 	}
 	return e.args[index]
 }
@@ -156,7 +179,7 @@ func (e *Erf) StackTrace() *StackTrace {
 }
 
 func (e *Erf) initialize(skip int) {
-	e.pc = getPC(int(4096/unsafe.Sizeof(uintptr(0))), skip)
+	e.pc = PC(DefaultPCSize, skip)
 }
 
 // New creates a new Erf object with the given text.

examples/README.md

@@ -0,0 +1,5 @@
+# examples
+
+- [example1](https://github.com/goinsane/erf/blob/master/examples/example1.go)
+  > go run examples/example1.go
+

example/main.go renamed to examples/example1.go

@@ -44,47 +44,47 @@ func main() {
 	if err := Foo(-1); err != nil {
 		fmt.Printf("%v\n", err)
 	}
-	fmt.Println("### \n")
+	fmt.Printf("### \n\n")
 
 	fmt.Println("### Foo: show with stack trace")
 	if err := Foo(-2); err != nil {
 		fmt.Printf("%+v\n", err)
 	}
-	fmt.Println("### \n")
+	fmt.Printf("### \n\n")
 
 	fmt.Println("### Foo: show with stack trace, and use space as whitespace instead of tab")
 	if err := Foo(-3); err != nil {
 		fmt.Printf("%+-v\n", err)
 	}
-	fmt.Println("### \n")
+	fmt.Printf("### \n\n")
 
 	fmt.Println("### Foo: show with last stack trace")
 	if err := Foo(-4); err != nil {
 		fmt.Printf("%+0v\n", err)
 	}
-	fmt.Println("### \n")
+	fmt.Printf("### \n\n")
 
 	fmt.Println("### Foo: show with stack trace with only file names except full path")
 	if err := Foo(-5); err != nil {
 		fmt.Printf("%+#v\n", err)
 	}
-	fmt.Println("### \n")
+	fmt.Printf("### \n\n")
 
 	fmt.Println("### Foo: show with stack trace with 2 whitespace chars of padding and 1 whitespace char of indent")
 	if err := Foo(-6); err != nil {
 		fmt.Printf("%+2.1v\n", err)
 	}
-	fmt.Println("### \n")
+	fmt.Printf("### \n\n")
 
 	fmt.Println("### Bar: show with stack trace")
 	if err := Bar(-7); err != nil {
 		fmt.Printf("%+v\n", err)
 	}
-	fmt.Println("### \n")
+	fmt.Printf("### \n\n")
 
 	fmt.Println("### Baz: show with stack trace")
 	if err := Baz(-8); err != nil {
 		fmt.Printf("%+v\n", err)
 	}
-	fmt.Println("### \n")
+	fmt.Printf("### \n\n")
 }

interfaces.go

@@ -1,10 +1,6 @@
 package erf
 
-type Wrapped interface {
-	Unwrap() error
-}
-
 type WrappedError interface {
-	Wrapped
 	error
+	Unwrap() error
 }

stack.go

@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"fmt"
 	"runtime"
-	"strings"
 )
 
 // StackCaller stores the information of stack caller.
@@ -34,6 +33,7 @@ func (c StackCaller) Format(f fmt.State, verb rune) {
 			prec = p
 		}
 		padding := bytes.Repeat([]byte{pad}, wid)
+		indent := bytes.Repeat([]byte{pad}, prec)
 		var str string
 		buf.Write(padding)
 		str = "???"
@@ -44,11 +44,12 @@ func (c StackCaller) Format(f fmt.State, verb rune) {
 		if f.Flag('+') {
 			buf.WriteRune('\n')
 			buf.Write(padding)
+			buf.Write(indent)
 			str = trimSrcPath(c.File)
 			if f.Flag('#') {
 				str = trimDirs(str)
 			}
-			buf.WriteString(fmt.Sprintf("%s%s:%d +%#x", strings.Repeat(string(pad), prec), str, c.Line, c.PC-c.Entry))
+			buf.WriteString(fmt.Sprintf("%s:%d +%#x", str, c.Line, c.PC-c.Entry))
 		}
 	}
 	if buf.Len() > 0 {
@@ -69,15 +70,17 @@ func NewStackTrace(pc ...uintptr) *StackTrace {
 		callers: make([]StackCaller, 0, len(pc)),
 	}
 	copy(t.pc, pc)
-	frames := runtime.CallersFrames(t.pc)
-	for {
-		frame, more := frames.Next()
-		caller := StackCaller{
-			Frame: frame,
-		}
-		t.callers = append(t.callers, caller)
-		if !more {
-			break
+	if len(t.pc) > 0 {
+		frames := runtime.CallersFrames(t.pc)
+		for {
+			frame, more := frames.Next()
+			caller := StackCaller{
+				Frame: frame,
+			}
+			t.callers = append(t.callers, caller)
+			if !more {
+				break
+			}
 		}
 	}
 	return t
@@ -147,7 +150,7 @@ func (t *StackTrace) Len() int {
 // Caller returns a StackCaller on the given index. It panics if index is out of range.
 func (t *StackTrace) Caller(index int) StackCaller {
 	if index < 0 || index >= t.Len() {
-		panic("index is out of range")
+		panic("index out of range")
 	}
 	return t.callers[index]
 }

util.go

@@ -7,6 +7,13 @@ import (
 	"strings"
 )
 
+// PC returns program counters by using runtime.Callers.
+func PC(size, skip int) []uintptr {
+	pc := make([]uintptr, size)
+	pc = pc[:runtime.Callers(skip, pc)]
+	return pc
+}
+
 func trimSrcPath(s string) string {
 	var r string
 	r = strings.TrimPrefix(s, build.Default.GOROOT+"/src/")
@@ -28,9 +35,3 @@ func trimDirs(s string) string {
 	}
 	return s
 }
-
-func getPC(size, skip int) []uintptr {
-	pc := make([]uintptr, size)
-	pc = pc[:runtime.Callers(skip, pc)]
-	return pc
-}