Add Newf and Wrapf functions

Add new functions to allow direct formatting.

Some linting cleanup was also performed.

Author: Dean Karn

Makefile

@@ -0,0 +1,19 @@
+GOCMD=go
+
+linters-install:
+	@gometalinter --version >/dev/null 2>&1 || { \
+		echo "installing linting tools..."; \
+		$(GOCMD) get github.com/alecthomas/gometalinter; \
+		gometalinter --install; \
+	}
+
+lint: linters-install
+	gometalinter --vendor --disable-all --enable=vet --enable=vetshadow --enable=golint --enable=megacheck --enable=ineffassign --enable=misspell --enable=errcheck --enable=goconst ./...
+
+test:
+	$(GOCMD) test -cover -race ./...
+
+bench:
+	$(GOCMD) test -bench=. -benchmem ./...
+
+.PHONY: test lint linters-install

README.md

@@ -1,6 +1,6 @@
 Package errors
 ============
-![Project status](https://img.shields.io/badge/version-3.2.1-green.svg)
+![Project status](https://img.shields.io/badge/version-3.3.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)

errors.go

@@ -2,6 +2,7 @@ package errors
 
 import (
 	"errors"
+	"fmt"
 )
 
 var (
@@ -20,12 +21,25 @@ func New(s string) Chain {
 	return wrap(errors.New(s), "", 0)
 }
 
+// Newf creates an error with the provided text and automatically wraps it with line information.
+// it also accepts a varadic for optional message formatting.
+func Newf(format string, a ...interface{}) Chain {
+	return wrap(fmt.Errorf(format, a...), "", 0)
+}
+
 // Wrap encapsulates the error, stores a contextual prefix and automatically obtains
 // a stack trace.
 func Wrap(err error, prefix string) Chain {
 	return wrap(err, prefix, 0)
 }
 
+// Wrapf encapsulates the error, stores a contextual prefix and automatically obtains
+// a stack trace.
+// it also accepts a varadic for prefix formatting.
+func Wrapf(err error, prefix string, a ...interface{}) Chain {
+	return wrap(err, fmt.Sprintf(prefix, a...), 0)
+}
+
 // WrapSkipFrames is a special version of Wrap that skips extra n frames when determining error location.
 // Normally only used when wrapping the library
 func WrapSkipFrames(err error, prefix string, n uint) Chain {

errors_test.go

@@ -9,14 +9,16 @@ import (
 
 func TestWrap(t *testing.T) {
 	defaultErr := fmt.Errorf("this is an %s", "error")
-	testWrapper := func (err error, prefix string) Chain {
+	testWrapper := func(err error, prefix string) Chain {
 		return WrapSkipFrames(err, prefix, 1)
 	}
 
 	err0 := New("42")
 	err1 := Wrap(defaultErr, "prefix 1")
 	err2 := err1.Wrap("prefix 2")
 	err3 := testWrapper(err2, "prefix 3")
+	err4 := Newf("this is an %s", "error")
+	err5 := Wrapf(defaultErr, "this is an %s", "error")
 
 	tests := []struct {
 		err Chain
@@ -43,6 +45,16 @@ func TestWrap(t *testing.T) {
 			pre: "TestWrap: ",
 			suf: "errors_test.go:19",
 		},
+		{
+			err: err4,
+			pre: "TestWrap: ",
+			suf: "errors_test.go:20",
+		},
+		{
+			err: err5,
+			pre: "TestWrap: ",
+			suf: "errors_test.go:21",
+		},
 	}
 
 	for i, tt := range tests {

helpers/awserrors/awserrors.go

@@ -5,26 +5,26 @@ import (
 	"github.com/go-playground/errors"
 )
 
+const (
+	transient = "Transient"
+)
+
 // AWSErrors helps classify io related errors
 func AWSErrors(c errors.Chain, err error) (cont bool) {
 	switch e := err.(type) {
-	case awserr.BatchError:
-		c.AddTypes("Transient", "Batch").AddTags(errors.T("aws_error_code", e.Code()))
-		return
-
 	case awserr.BatchedErrors:
-		c.AddTypes("Transient", "Batch")
+		_ = c.AddTypes(transient, "Batch")
 		return
 
 	case awserr.RequestFailure:
-		c.AddTypes("Transient", "Request").AddTags(
+		_ = c.AddTypes(transient, "Request").AddTags(
 			errors.T("status_code", e.StatusCode()),
 			errors.T("request_id", e.RequestID()),
 		)
 		return
 
 	case awserr.Error:
-		c.AddTypes("General", "Error").AddTags(errors.T("aws_error_code", e.Code()))
+		_ = c.AddTypes("General", "Error").AddTags(errors.T("aws_error_code", e.Code()))
 		return
 	}
 	return true

helpers/ioerrors/ioerrors.go

@@ -10,22 +10,22 @@ import (
 func IOErrors(c errors.Chain, err error) (cont bool) {
 	switch err {
 	case io.EOF:
-		c.AddTypes("io")
+		_ = c.AddTypes("io")
 		return
 	case io.ErrClosedPipe:
-		c.AddTypes("Permanent", "io")
+		_ = c.AddTypes("Permanent", "io")
 		return
 	case io.ErrNoProgress:
-		c.AddTypes("Permanent", "io")
+		_ = c.AddTypes("Permanent", "io")
 		return
 	case io.ErrShortBuffer:
-		c.AddTypes("Permanent", "io")
+		_ = c.AddTypes("Permanent", "io")
 		return
 	case io.ErrShortWrite:
-		c.AddTypes("Permanent", "io")
+		_ = c.AddTypes("Permanent", "io")
 		return
 	case io.ErrUnexpectedEOF:
-		c.AddTypes("Transient", "io")
+		_ = c.AddTypes("Transient", "io")
 		return
 	}
 	return true

helpers/neterrors/neterrors.go

@@ -6,27 +6,32 @@ import (
 	"github.com/go-playground/errors"
 )
 
+const (
+	permanent = "Permanent"
+	transient = "Transient"
+)
+
 // NETErrors helps classify io related errors
 func NETErrors(c errors.Chain, err error) (cont bool) {
 	switch e := err.(type) {
 	case *net.AddrError:
-		tp := "Permanent"
+		tp := permanent
 		if e.Temporary() {
-			tp = "Transient"
+			tp = transient
 		}
-		c.AddTypes(tp, "net").AddTags(
+		_ = c.AddTypes(tp, "net").AddTags(
 			errors.T("addr", e.Addr),
 			errors.T("is_timeout", e.Timeout()),
 			errors.T("is_temporary", e.Temporary()),
 		)
 		return false
 
 	case *net.DNSError:
-		tp := "Permanent"
+		tp := permanent
 		if e.Temporary() {
-			tp = "Transient"
+			tp = transient
 		}
-		c.AddTypes(tp, "net").AddTags(
+		_ = c.AddTypes(tp, "net").AddTags(
 			errors.T("name", e.Name),
 			errors.T("server", e.Server),
 			errors.T("is_timeout", e.Timeout()),
@@ -35,18 +40,18 @@ func NETErrors(c errors.Chain, err error) (cont bool) {
 		return false
 
 	case *net.ParseError:
-		c.AddTypes("Permanent", "net").AddTags(
+		_ = c.AddTypes(permanent, "net").AddTags(
 			errors.T("type", e.Type),
 			errors.T("text", e.Text),
 		)
 		return false
 
 	case *net.OpError:
-		tp := "Permanent"
+		tp := permanent
 		if e.Temporary() {
-			tp = "Transient"
+			tp = transient
 		}
-		c.AddTypes(tp, "net").AddTags(
+		_ = c.AddTypes(tp, "net").AddTags(
 			errors.T("op", e.Op),
 			errors.T("net", e.Net),
 			errors.T("addr", e.Addr),
@@ -56,19 +61,19 @@ func NETErrors(c errors.Chain, err error) (cont bool) {
 		)
 		return false
 	case net.UnknownNetworkError:
-		tp := "Permanent"
+		tp := permanent
 		if e.Temporary() {
-			tp = "Transient"
+			tp = transient
 		}
-		c.AddTypes(tp, "net").AddTags(
+		_ = c.AddTypes(tp, "net").AddTags(
 			errors.T("is_timeout", e.Timeout()),
 			errors.T("is_temporary", e.Temporary()),
 		)
 	}
 
 	switch err {
 	case net.ErrWriteToConnected:
-		c.AddTypes("Transient", "net")
+		_ = c.AddTypes(transient, "net")
 		return false
 	}
 	return true

stack.go

@@ -84,22 +84,22 @@ func (f Frame) Format(s fmt.State, verb rune) {
 			pc := f.pc()
 			fn := runtime.FuncForPC(pc)
 			if fn == nil {
-				io.WriteString(s, "unknown")
+				_, _ = io.WriteString(s, "unknown")
 			} else {
 				file, _ := fn.FileLine(pc)
 				fmt.Fprintf(s, "%s\n\t%s", fn.Name(), file)
 			}
 		default:
-			io.WriteString(s, path.Base(f.file()))
+			_, _ = io.WriteString(s, path.Base(f.file()))
 		}
 	case 'd':
 		fmt.Fprintf(s, "%d", f.line())
 	case 'n':
 		name := runtime.FuncForPC(f.pc()).Name()
-		io.WriteString(s, funcname(name))
+		_, _ = io.WriteString(s, funcname(name))
 	case 'v':
 		f.Format(s, 's')
-		io.WriteString(s, ":")
+		_, _ = io.WriteString(s, ":")
 		f.Format(s, 'd')
 	}
 }
@@ -114,7 +114,7 @@ func funcname(name string) string {
 
 func st(skipFrames int) string {
 	s := callers()
-	f := fr(s, 3 + skipFrames)
+	f := fr(s, 3+skipFrames)
 	name := fmt.Sprintf("%n", f)
 	file := fmt.Sprintf("%+s", f)
 	line := fmt.Sprintf("%d", f)