Merge pull request #1 from goinsane/develop

v0.1.0

Author: orkunkaraduman

README.md

@@ -0,0 +1,7 @@
+# erf
+
+[![Go Reference](https://pkg.go.dev/badge/github.com/goinsane/erf.svg)](https://pkg.go.dev/github.com/goinsane/erf)
+
+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).

erf.go

@@ -0,0 +1,200 @@
+// Package erf provides error management with stack trace.
+package erf
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"unsafe"
+)
+
+// Erf is an error type that wraps the underlying error that stores and formats the stack trace.
+type Erf struct {
+	err        error
+	format     string
+	args       []interface{}
+	tagIndexes map[string]int
+	pc         []uintptr
+}
+
+// Error is implementation of error.
+func (e *Erf) Error() string {
+	return e.err.Error()
+}
+
+// Unwrap returns the underlying error.
+func (e *Erf) Unwrap() error {
+	if err, ok := e.err.(WrappedError); ok {
+		return err.Unwrap()
+	}
+	return nil
+}
+
+// Format is implementation of fmt.Formatter.
+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
+			}
+			format += fmt.Sprintf("%d.%d", wid, prec)
+			format += "s"
+			buf.WriteRune('\n')
+			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')
+						buf.WriteString(e2.Error())
+						buf.WriteRune('\n')
+						buf.WriteString(fmt.Sprintf(format, e2.StackTrace()))
+						buf.WriteRune('\n')
+					}
+					if wErr, ok := err.(WrappedError); ok {
+						err = wErr.Unwrap()
+					} else {
+						err = nil
+					}
+				}
+			}
+		}
+	}
+	if buf.Len() > 0 {
+		_, _ = f.Write(buf.Bytes())
+	}
+}
+
+// Fmt returns the format argument of the formatting functions (Newf, Errorf or Wrap) that created Erf.
+func (e *Erf) Fmt() string {
+	return e.format
+}
+
+// Len returns the length of the arguments slice.
+func (e *Erf) Len() int {
+	return len(e.args)
+}
+
+// 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")
+	}
+	return e.args[index]
+}
+
+// Args returns all argument values. It returns nil if Erf didn't create with formatting functions.
+func (e *Erf) Args() []interface{} {
+	if e.args == nil {
+		return nil
+	}
+	result := make([]interface{}, len(e.args))
+	copy(result, e.args)
+	return result
+}
+
+// Attach attaches tags to arguments, if arguments are given. It panics if an error occurs.
+func (e *Erf) Attach(tags ...string) *Erf {
+	if e.args == nil {
+		panic("args are not using")
+	}
+	if e.tagIndexes != nil {
+		panic("tags are already attached")
+	}
+	if len(tags) > len(e.args) {
+		panic("tags are more than args")
+	}
+	tagIndexes := make(map[string]int, len(tags))
+	for index, tag := range tags {
+		if _, ok := tagIndexes[tag]; ok {
+			panic("tag is already defined")
+		}
+		tagIndexes[tag] = index
+	}
+	e.tagIndexes = tagIndexes
+	return e
+}
+
+// Tag returns an argument value on the given tag. It panics if tag is not found.
+func (e *Erf) Tag(tag string) interface{} {
+	index := -1
+	if idx, ok := e.tagIndexes[tag]; ok {
+		index = idx
+	}
+	if index < 0 || index >= e.Len() {
+		panic("tag is not found")
+	}
+	return e.args[index]
+}
+
+// PC returns program counters.
+func (e *Erf) PC() []uintptr {
+	result := make([]uintptr, len(e.pc))
+	copy(result, e.pc)
+	return result
+}
+
+// StackTrace returns a StackTrace of Erf.
+func (e *Erf) StackTrace() *StackTrace {
+	return NewStackTrace(e.pc...)
+}
+
+func (e *Erf) initialize(skip int) {
+	e.pc = getPC(int(4096/unsafe.Sizeof(uintptr(0))), skip)
+}
+
+// New creates a new Erf object with the given text.
+func New(text string) *Erf {
+	e := &Erf{
+		err: errors.New(text),
+	}
+	e.initialize(4)
+	return e
+}
+
+func newf(format string, args ...interface{}) *Erf {
+	e := &Erf{
+		err:    fmt.Errorf(format, args...),
+		format: format,
+		args:   make([]interface{}, len(args)),
+	}
+	copy(e.args, args)
+	return e
+}
+
+// Newf creates a new Erf object with the given format and args.
+func Newf(format string, args ...interface{}) *Erf {
+	e := newf(format, args...)
+	e.initialize(4)
+	return e
+}
+
+// Errorf is similar with Newf except that it returns the error interface instead of the Erf pointer.
+func Errorf(format string, a ...interface{}) error {
+	e := newf(format, a...)
+	e.initialize(4)
+	return e
+}
+
+// Wrap wraps the given error as the underlying error and returns a new Erf object as the error interface.
+func Wrap(err error) error {
+	e := newf("%w", err)
+	e.initialize(4)
+	return e
+}

example/main.go

@@ -0,0 +1,90 @@
+// +build ignore
+
+package main
+
+import (
+	"fmt"
+
+	"github.com/goinsane/erf"
+)
+
+var (
+	ErrValueBelowZero = erf.New("value below zero")
+)
+
+type InvalidArgumentError struct{ *erf.Erf }
+
+func NewInvalidArgumentError(name string, err error) error {
+	return (&InvalidArgumentError{erf.Newf("invalid argument %q: %w", name, err)}).Attach("name")
+}
+
+func Foo(x int) error {
+	if x < 0 {
+		return NewInvalidArgumentError("x", ErrValueBelowZero)
+	}
+	return nil
+}
+
+func Bar(y int) error {
+	if y < 0 {
+		return erf.Errorf("%w: %d", ErrValueBelowZero, y)
+	}
+	return nil
+}
+
+func Baz(z int) error {
+	if z < 0 {
+		return erf.Wrap(ErrValueBelowZero)
+	}
+	return nil
+}
+
+func main() {
+	fmt.Println("### Foo: just show error text")
+	if err := Foo(-1); err != nil {
+		fmt.Printf("%v\n", err)
+	}
+	fmt.Println("### \n")
+
+	fmt.Println("### Foo: show with stack trace")
+	if err := Foo(-2); err != nil {
+		fmt.Printf("%+v\n", err)
+	}
+	fmt.Println("### \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.Println("### Foo: show with last stack trace")
+	if err := Foo(-4); err != nil {
+		fmt.Printf("%+0v\n", err)
+	}
+	fmt.Println("### \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.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.Println("### Bar: show with stack trace")
+	if err := Bar(-7); err != nil {
+		fmt.Printf("%+v\n", err)
+	}
+	fmt.Println("### \n")
+
+	fmt.Println("### Baz: show with stack trace")
+	if err := Baz(-8); err != nil {
+		fmt.Printf("%+v\n", err)
+	}
+	fmt.Println("### \n")
+}

interfaces.go

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