Merge pull request #2 from go-playground/structural-updates

update internals

Author: Dean Karn

README.md

@@ -1,6 +1,6 @@
 Package errors
 ============
-![Project status](https://img.shields.io/badge/version-1.3.0-green.svg)
+![Project status](https://img.shields.io/badge/version-2.0.0-green.svg)
 [![Build Status](https://semaphoreci.com/api/v1/joeybloggs/errors/branches/master/badge.svg)](https://semaphoreci.com/joeybloggs/errors)
 [![Go Report Card](https://goreportcard.com/badge/github.com/go-playground/errors)](https://goreportcard.com/report/github.com/go-playground/errors)
 [![GoDoc](https://godoc.org/github.com/go-playground/errors?status.svg)](https://godoc.org/github.com/go-playground/errors)
@@ -51,12 +51,8 @@ func main() {
 	fmt.Println(cause)
 
 	// can even still inspect the internal error
-	fmt.Println(errors.IsErr(err, io.EOF)) // will extract the cause for you
-	fmt.Println(errors.IsErr(cause, io.EOF))
-
-	// or manually with access to base fields
-	wrapped := cause.(*errors.Wrapped)
-	fmt.Println(wrapped.Err == io.EOF)
+	fmt.Println(errors.Cause(err) == io.EOF) // will extract the cause for you
+	fmt.Println(errors.Cause(cause) == io.EOF)
 }
 
 func level1(value string) error {

_examples/basic/main.go

@@ -19,12 +19,8 @@ func main() {
 	fmt.Println(cause)
 
 	// can even still inspect the internal error
-	fmt.Println(errors.IsErr(err, io.EOF)) // will extract the cause for you
-	fmt.Println(errors.IsErr(cause, io.EOF))
-
-	// or manually with access to base fields
-	wrapped := cause.(*errors.Wrapped)
-	fmt.Println(wrapped.Err == io.EOF)
+	fmt.Println(errors.Cause(err) == io.EOF) // will extract the cause for you
+	fmt.Println(errors.Cause(cause) == io.EOF)
 }
 
 func level1(value string) error {

chain.go

@@ -0,0 +1,108 @@
+package errors
+
+import (
+	"fmt"
+	"strings"
+)
+
+// T is a shortcut to make a Tag
+func T(key string, value interface{}) Tag {
+	return Tag{Key: key, Value: value}
+}
+
+// Tag contains a single key value conbination
+// to be attached to your error
+type Tag struct {
+	Key   string
+	Value interface{}
+}
+
+func newLink(err error, prefix string) *Link {
+	return &Link{
+		Err:    err,
+		Prefix: prefix,
+		Source: st(),
+	}
+
+}
+
+// Chain contains the chained errors, the links, of the chains if you will
+type Chain []*Link
+
+// Error returns the formatted error string
+func (c Chain) Error() string {
+	lines := make([]string, 0, len(c))
+	// source=<source> <prefix>: <error> tag=value tag2=value2 types=type1,type2
+	for i := len(c) - 1; i >= 0; i-- {
+		line := c[i].formatError()
+		lines = append(lines, line)
+	}
+	return strings.Join(lines, "\n")
+}
+
+// Link contains a single error entry, unless it's the top level error, in
+// which case it only contains an array of errors
+type Link struct {
+
+	// Err is the wrapped error, either the original or already wrapped
+	Err error
+
+	// Prefix contains the error prefix text
+	Prefix string
+
+	// Type stores one or more categorized types of error set by the caller using WithTypes and is optional
+	Types []string
+
+	// Tags contains an array of tags associated with this error, if any
+	Tags []Tag
+
+	// Source contains the name, file and lines obtained from the stack trace
+	Source string
+}
+
+// formatError prints a single Links error
+func (l *Link) formatError() string {
+	line := fmt.Sprintf("source=%s ", l.Source)
+
+	if l.Prefix != "" {
+		line += l.Prefix + ": "
+	}
+
+	line += l.Err.Error()
+
+	for _, tag := range l.Tags {
+		line += fmt.Sprintf(" %s=%v", tag.Key, tag.Value)
+	}
+
+	if len(l.Types) > 0 {
+		line += " types=" + strings.Join(l.Types, ",")
+	}
+	return line
+}
+
+// helper method to get the current *Link from the top level
+func (c Chain) current() *Link {
+	return c[len(c)-1]
+}
+
+// WithTags allows the addition of multiple tags
+func (c Chain) WithTags(tags ...Tag) Chain {
+	l := c.current()
+	if len(l.Tags) == 0 {
+		l.Tags = make([]Tag, 0, len(tags))
+	}
+	l.Tags = append(l.Tags, tags...)
+	return c
+}
+
+// WithTag allows the addition of a single tag
+func (c Chain) WithTag(key string, value interface{}) Chain {
+	return c.WithTags(Tag{Key: key, Value: value})
+}
+
+// WithTypes sets one or more categorized types on the Link error
+func (c Chain) WithTypes(typ ...string) Chain {
+	l := c.current()
+	l.Types = append(l.Types, typ...)
+	return c
+}

errors.go

@@ -1,6 +1,8 @@
 package errors
 
-import "errors"
+import (
+	"errors"
+)
 
 var (
 	helpers []Helper
@@ -13,74 +15,70 @@ func RegisterHelper(helper Helper) {
 	helpers = append(helpers, helper)
 }
 
+// New creates an error with the provided text and automatically wraps it with line information.
+func New(s string) Chain {
+	return wrap(errors.New(s), "")
+}
+
 // Wrap encapsulates the error, stores a contextual prefix and automatically obtains
 // a stack trace.
-func Wrap(err error, prefix string) (w *Wrapped) {
+func Wrap(err error, prefix string) Chain {
 	return wrap(err, prefix)
 }
 
-func wrap(err error, prefix string) (w *Wrapped) {
+func wrap(err error, prefix string) (c Chain) {
 	var ok bool
-	if w, ok = err.(*Wrapped); ok {
-		w.Errors = append(w.Errors, newWrapped(err, prefix))
+	if c, ok = err.(Chain); ok {
+		c = append(c, newLink(err, prefix))
 	} else {
-		w = &Wrapped{
-			Errors: []*Wrapped{newWrapped(err, prefix)},
-		}
+		c = Chain{newLink(err, prefix)}
 	}
 	for _, h := range helpers {
-		if !h(w, err) {
+		if !h(c, err) {
 			break
 		}
 	}
 	return
 }
 
+// Cause extracts and returns the root wrapped error (the naked error with no additional information
+func Cause(err error) error {
+	switch t := err.(type) {
+	case Chain:
+		return t[0].Err
+	default:
+		return err
+	}
+	// TODO: lookup via Cause interface recursively on error
+}
+
 // HasType is a helper function that will recurse up from the root error and check that the provided type
 // is present using an equality check
 func HasType(err error, typ string) bool {
-	w, ok := err.(*Wrapped)
-	if !ok {
-		return false
-	}
-	for i := len(w.Errors) - 1; i >= 0; i-- {
-		for j := 0; j < len(w.Errors[i].Types); j++ {
-			if w.Errors[i].Types[j] == typ {
-				return true
+	switch t := err.(type) {
+	case Chain:
+		for i := len(t) - 1; i >= 0; i-- {
+			for j := 0; j < len(t[i].Types); j++ {
+				if t[i].Types[j] == typ {
+					return true
+				}
 			}
 		}
 	}
 	return false
 }
 
-// Cause extracts and returns the root error
-func Cause(err error) error {
-	if w, ok := err.(*Wrapped); ok {
-		// if root level error
-		if len(w.Errors) > 0 {
-			return w.Errors[0]
-		}
-		// already extracted error
-		return w
-	}
-	return err
-}
-
-// IsErr will fetch the root error, and check the original error against the provided type
-// eg. errors.IsErr(io.EOF)
-func IsErr(err, errType error) bool {
-	if w, ok := err.(*Wrapped); ok {
-		// if root level error
-		if len(w.Errors) > 0 {
-			return w.Errors[0].Err == errType
+// LookupTag recursively searches for the provided tag and returns it's value or nil
+func LookupTag(err error, key string) interface{} {
+	switch t := err.(type) {
+	case Chain:
+		for i := len(t) - 1; i >= 0; i-- {
+			for j := 0; j < len(t[i].Tags); j++ {
+				if t[i].Tags[j].Key == key {
+					return t[i].Tags[j].Value
+				}
+			}
 		}
-		// already extracted error
-		return w.Err == errType
 	}
-	return err == errType
-}
-
-// New creates an error with the provided text and automatically wraps it with line information.
-func New(s string) *Wrapped {
-	return wrap(errors.New(s), "")
+	return nil
 }

errors_test.go

@@ -98,30 +98,30 @@ func TestCause(t *testing.T) {
 	err := Wrap(defaultErr, "prefix")
 	err = Wrap(err, "prefix2")
 	cause := Cause(err)
-	expect := "prefix: this is an error"
-	if !strings.HasSuffix(cause.Error(), expect) {
+	expect := "this is an error"
+	if cause.Error() != expect {
 		t.Fatalf("want %s got %s", expect, err.Error())
 	}
 }
 
-func TestIsErr(t *testing.T) {
+func TestCause2(t *testing.T) {
 	err := Wrap(io.EOF, "prefix")
 	err = Wrap(err, "prefix2")
 
-	if !IsErr(err, io.EOF) {
+	if Cause(err) != io.EOF {
 		t.Fatalf("want %t got %t", true, false)
 	}
 	cause := Cause(err)
-	if !IsErr(cause, io.EOF) {
+	if Cause(cause) != io.EOF {
 		t.Fatalf("want %t got %t", true, false)
 	}
-	if !IsErr(io.EOF, io.EOF) {
+	if Cause(io.EOF) != io.EOF {
 		t.Fatalf("want %t got %t", true, false)
 	}
 }
 
 func TestHelpers(t *testing.T) {
-	fn := func(w *Wrapped, err error) (cont bool) {
+	fn := func(w Chain, err error) (cont bool) {
 		w.WithTypes("Test").WithTags(T("test", "tag")).WithTag("foo", "bar")
 		return false
 	}
@@ -132,3 +132,10 @@ func TestHelpers(t *testing.T) {
 		t.Errorf("Expected to have type 'Test'")
 	}
 }
+
+func TestLookupTag(t *testing.T) {
+	err := Wrap(io.EOF, "prefix").WithTag("Key", "Value")
+	if LookupTag(err, "Key").(string) != "Value" {
+		t.Fatalf("want %s got %v", "Value", LookupTag(err, "Key"))
+	}
+}

helpers.go

@@ -1,6 +1,6 @@
 package errors
 
 // Helper is a function which will automatically extract Type and Tag information based on the supplied err and
-// add it to the supplied *Wrapped error; this can be used independently or by registering using errors.REgisterHelper(...),
+// add it to the supplied *Link error; this can be used independently or by registering using errors.REgisterHelper(...),
 // which will run the registered helper every time errors.Wrap(...) is called.
-type Helper func(*Wrapped, error) bool
+type Helper func(Chain, error) bool

helpers/awserrors/awserrors.go

@@ -6,25 +6,25 @@ import (
 )
 
 // AWSErrors helps classify io related errors
-func AWSErrors(w *errors.Wrapped, err error) (cont bool) {
+func AWSErrors(c errors.Chain, err error) (cont bool) {
 	switch e := err.(type) {
 	case awserr.BatchError:
-		w.WithTypes("Transient", "Batch").WithTags(errors.T("aws_error_code", e.Code()))
+		c.WithTypes("Transient", "Batch").WithTags(errors.T("aws_error_code", e.Code()))
 		return
 
 	case awserr.BatchedErrors:
-		w.WithTypes("Transient", "Batch")
+		c.WithTypes("Transient", "Batch")
 		return
 
 	case awserr.RequestFailure:
-		w.WithTypes("Transient", "Request").WithTags(
+		c.WithTypes("Transient", "Request").WithTags(
 			errors.T("status_code", e.StatusCode()),
 			errors.T("request_id", e.RequestID()),
 		)
 		return
 
 	case awserr.Error:
-		w.WithTypes("General", "Error").WithTags(errors.T("aws_error_code", e.Code()))
+		c.WithTypes("General", "Error").WithTags(errors.T("aws_error_code", e.Code()))
 		return
 	}
 	return true

helpers/ioerrors/ioerrors.go

@@ -7,25 +7,25 @@ import (
 )
 
 // IOErrors helps classify io related errors
-func IOErrors(w *errors.Wrapped, err error) (cont bool) {
+func IOErrors(c errors.Chain, err error) (cont bool) {
 	switch err {
 	case io.EOF:
-		w.WithTypes("io")
+		c.WithTypes("io")
 		return
 	case io.ErrClosedPipe:
-		w.WithTypes("Permanent", "io")
+		c.WithTypes("Permanent", "io")
 		return
 	case io.ErrNoProgress:
-		w.WithTypes("Permanent", "io")
+		c.WithTypes("Permanent", "io")
 		return
 	case io.ErrShortBuffer:
-		w.WithTypes("Permanent", "io")
+		c.WithTypes("Permanent", "io")
 		return
 	case io.ErrShortWrite:
-		w.WithTypes("Permanent", "io")
+		c.WithTypes("Permanent", "io")
 		return
 	case io.ErrUnexpectedEOF:
-		w.WithTypes("Transient", "io")
+		c.WithTypes("Transient", "io")
 		return
 	}
 	return true