Initial commit

Author: rlisagor

error.go

@@ -0,0 +1,75 @@
+package cerrors
+
+import (
+	"fmt"
+)
+
+func New(msg string) error {
+	return &cerror{
+		msg:   msg,
+		frame: Caller(1),
+	}
+}
+
+func Newf(msg string, args ...interface{}) error {
+	return &cerror{
+		msg:   fmt.Sprintf(msg, args...),
+		frame: Caller(1),
+	}
+}
+
+func Wrap(err error, msg string) error {
+	return &cerror{
+		msg:   msg,
+		next:  err,
+		frame: Caller(1),
+	}
+}
+
+func Wrapf(err error, msg string, args ...interface{}) error {
+	return &cerror{
+		msg:   fmt.Sprintf(msg, args...),
+		next:  err,
+		frame: Caller(1),
+	}
+}
+
+type cerror struct {
+	msg   string
+	next  error
+	frame Frame
+}
+
+func (c *cerror) Format(s fmt.State, verb rune) {
+	switch verb {
+	case 'v':
+		if s.Flag('+') || s.Flag('#') {
+			Format(c, s, s.Flag('#'))
+			return
+		}
+		fallthrough
+	case 's':
+		fmt.Fprint(s, c.Error())
+	default:
+		fmt.Fprintf(s, "%%!%s(cerror)", string(verb))
+	}
+}
+
+func (c *cerror) OwnMessage() string {
+	return c.msg
+}
+
+func (c *cerror) Frame() Frame {
+	return c.frame
+}
+
+func (c *cerror) Error() string {
+	if c.next != nil {
+		return c.msg + ": " + c.next.Error()
+	}
+	return c.msg
+}
+
+func (c *cerror) Unwrap() error {
+	return c.next
+}

error_test.go

@@ -0,0 +1,182 @@
+package cerrors_test
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/1debit/cerrors"
+)
+
+func TestUnwrapMessage(t *testing.T) {
+	tests := []struct {
+		name   string
+		err    error
+		result string
+	}{
+		{
+			name:   "at the end with a colon",
+			err:    fmt.Errorf("one: %w", fmt.Errorf("two: %w", errors.New("three"))),
+			result: "one",
+		},
+		{
+			name:   "at the end without colon",
+			err:    fmt.Errorf("one %w", fmt.Errorf("two: %w", errors.New("three"))),
+			result: "one",
+		},
+		{
+			name:   "in the middle",
+			err:    fmt.Errorf("foo %w bar", fmt.Errorf("two: %w", errors.New("three"))),
+			result: "foo * bar",
+		},
+		{
+			name:   "chained without wrapping",
+			err:    fmt.Errorf("one: %v", fmt.Errorf("two: %w", errors.New("three"))),
+			result: "one: two: three",
+		},
+		{
+			name:   "not chained",
+			err:    errors.New("foo bar"),
+			result: "foo bar",
+		},
+		{
+			name:   "empty",
+			err:    errors.New(""),
+			result: "",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			assert.Equal(t, test.result, cerrors.UnwrapMessage(test.err))
+		})
+	}
+}
+
+func TestCerrorFormat(t *testing.T) {
+	var (
+		location         = `    \S*error_test.go:\d+`
+		locationIndented = `        \S*error_test.go:\d+`
+		function         = `    github.com/1debit/cerrors_test.TestCerrorFormat.*`
+	)
+
+	tests := []struct {
+		name   string
+		chain  []func(error) error
+		verb   string
+		root   error
+		result []string
+	}{
+		{
+			name:   "single error, short",
+			root:   cerrors.New("foo"),
+			verb:   "%v",
+			result: []string{"foo"},
+		},
+		{
+			name: "multiple levels wrapped, short",
+			root: cerrors.New("one"),
+			chain: []func(error) error{
+				func(e error) error { return cerrors.Wrap(e, "two") },
+				func(e error) error { return cerrors.Wrap(e, "three") },
+			},
+			verb:   "%v",
+			result: []string{"three: two: one"},
+		},
+		{
+			name: "including non-cerror, short",
+			root: cerrors.New("one"),
+			chain: []func(error) error{
+				func(e error) error { return fmt.Errorf("two: %w", e) },
+				func(e error) error { return cerrors.Wrap(e, "three") },
+			},
+			verb:   "%v",
+			result: []string{"three: two: one"},
+		},
+		{
+			name: "single error, detailed",
+			root: cerrors.New("foo"),
+			verb: "%+v",
+			result: []string{
+				"foo",
+				location,
+			},
+		},
+		{
+			name: "multiple levels wrapped, detailed",
+			root: cerrors.New("one"),
+			chain: []func(error) error{
+				func(e error) error { return cerrors.Wrap(e, "two") },
+				func(e error) error { return cerrors.Wrap(e, "three") },
+			},
+			verb: "%+v",
+			result: []string{
+				"three",
+				location,
+				"  - two",
+				location,
+				"  - one",
+				location,
+			},
+		},
+		{
+			name: "including non-cerror, detailed",
+			root: cerrors.New("one"),
+			chain: []func(error) error{
+				func(e error) error { return fmt.Errorf("two: %w", e) },
+				func(e error) error { return cerrors.Wrap(e, "three") },
+			},
+			verb: "%+v",
+			result: []string{
+				"three",
+				location,
+				"  - two",
+				"  - one",
+				location,
+			},
+		},
+		{
+			name: "including non-cerror, detailed with functions",
+			root: cerrors.New("one"),
+			chain: []func(error) error{
+				func(e error) error { return fmt.Errorf("two: %w", e) },
+				func(e error) error { return cerrors.Wrap(e, "three") },
+			},
+			verb: "%#v",
+			result: []string{
+				"three",
+				function,
+				locationIndented,
+				"  - two",
+				"  - one",
+				function,
+				locationIndented,
+			},
+		},
+		{
+			name:   "invalid verb",
+			root:   cerrors.New("one"),
+			verb:   "%d",
+			result: []string{`%!d\(cerror\)`},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			err := test.root
+			for _, f := range test.chain {
+				err = f(err)
+			}
+
+			result := strings.Split(strings.TrimSpace(fmt.Sprintf(test.verb, err)), "\n")
+			require.Len(t, result, len(test.result))
+			for idx, line := range test.result {
+				assert.Regexp(t, "^"+line+"$", result[idx], "at line %d", idx)
+			}
+		})
+	}
+}

format.go

@@ -0,0 +1,90 @@
+package cerrors
+
+import (
+	"fmt"
+	"io"
+	"strings"
+)
+
+type withOwnMessage interface {
+	OwnMessage() string
+}
+
+type withFrame interface {
+	Frame() Frame
+}
+
+type withUnwrap interface {
+	Unwrap() error
+}
+
+func Format(err error, s io.Writer, withFunctions bool) {
+	var prefix string
+
+	for err != nil {
+		next := getNext(err)
+		fmt.Fprintln(s, prefix+getOwnMessage(err, next))
+
+		if wFrame, ok := err.(withFrame); ok {
+			wFrame.Frame().Format(s, withFunctions)
+		}
+
+		prefix = "  - "
+		err = next
+	}
+}
+
+func getOwnMessage(err, next error) string {
+	if wMessage, ok := err.(withOwnMessage); ok {
+		return wMessage.OwnMessage()
+	} else if next != nil {
+		return unwrapMessageStr(err.Error(), next.Error())
+	} else {
+		return err.Error()
+	}
+}
+
+func getNext(err error) error {
+	if wUnwrap, ok := err.(withUnwrap); ok {
+		return wUnwrap.Unwrap()
+	}
+	return nil
+}
+
+// UnwrapMessage returns the portion of the error message which does not repeat
+// in the wrapped error.
+//
+// Examples:
+//
+// err := errors.New("couldn't")
+//
+// UnwrapMessage(fmt.Errorf("doing foo: %w", err)) // => "doing foo"
+// UnwrapMessage(fmt.Errorf("doing foo %w", err)) // => "doing foo"
+// UnwrapMessage(fmt.Errorf("failed (%w) while doing foo", err)))  // => "failed (*) while doing foo"
+func UnwrapMessage(err error) string {
+	msg := err.Error()
+	if wrapper, ok := err.(withUnwrap); ok {
+		wrapped := wrapper.Unwrap()
+		if wrapped != nil {
+			if withOwnMessage, ok := wrapped.(withOwnMessage); ok {
+				return withOwnMessage.OwnMessage()
+			}
+			wrappedMsg := wrapped.Error()
+			return unwrapMessageStr(msg, wrappedMsg)
+		}
+	}
+
+	return msg
+}
+
+func unwrapMessageStr(parent, child string) string {
+	msg := parent
+	if idx := strings.Index(parent, child); idx > 0 {
+		if idx+len(child) == len(parent) {
+			msg = strings.TrimRight(parent[:idx], ": ")
+		} else {
+			msg = parent[:idx] + "*" + parent[idx+len(child):]
+		}
+	}
+	return msg
+}