Merge pull request #3 from go-playground/mutation-implying-names

Renamed With* methods to Add* to imply that they mutate original object

Author: Dean Karn

README.md

@@ -64,7 +64,7 @@ func level1(value string) error {
 
 func level2(value string) error {
 	err := fmt.Errorf("this is an %s", "error")
-	return errors.Wrap(err, "failed to do something").WithTypes("Permanent").WithTags(errors.T("value", value))
+	return errors.Wrap(err, "failed to do something").AddTypes("Permanent").AddTags(errors.T("value", value))
 }
 ```
 

_examples/basic/main.go

@@ -32,5 +32,5 @@ func level1(value string) error {
 
 func level2(value string) error {
 	err := fmt.Errorf("this is an %s", "error")
-	return errors.Wrap(err, "failed to do something").WithTypes("Permanent").WithTags(errors.T("value", value))
+	return errors.Wrap(err, "failed to do something").AddTypes("Permanent").AddTags(errors.T("value", value))
 }

chain.go

@@ -50,7 +50,7 @@ type Link struct {
 	// 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
+	// Type stores one or more categorized types of error set by the caller using AddTypes and is optional
 	Types []string
 
 	// Tags contains an array of tags associated with this error, if any
@@ -85,8 +85,8 @@ func (c Chain) current() *Link {
 	return c[len(c)-1]
 }
 
-// WithTags allows the addition of multiple tags
-func (c Chain) WithTags(tags ...Tag) Chain {
+// AddTags allows the addition of multiple tags
+func (c Chain) AddTags(tags ...Tag) Chain {
 	l := c.current()
 	if len(l.Tags) == 0 {
 		l.Tags = make([]Tag, 0, len(tags))
@@ -95,13 +95,13 @@ func (c Chain) WithTags(tags ...Tag) Chain {
 	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})
+// AddTag allows the addition of a single tag
+func (c Chain) AddTag(key string, value interface{}) Chain {
+	return c.AddTags(Tag{Key: key, Value: value})
 }
 
-// WithTypes sets one or more categorized types on the Link error
-func (c Chain) WithTypes(typ ...string) Chain {
+// AddTypes sets one or more categorized types on the Link error
+func (c Chain) AddTypes(typ ...string) Chain {
 	l := c.current()
 	l.Types = append(l.Types, typ...)
 	return c

errors_test.go

@@ -42,7 +42,7 @@ func TestTags(t *testing.T) {
 	defaultErr := fmt.Errorf("this is an %s", "error")
 
 	for i, tt := range tests {
-		err := Wrap(defaultErr, "prefix").WithTags(tt.tags...)
+		err := Wrap(defaultErr, "prefix").AddTags(tt.tags...)
 		if !strings.HasSuffix(err.Error(), tt.err) {
 			t.Fatalf("IDX: %d want %s got %s", i, tt.err, err.Error())
 		}
@@ -65,7 +65,7 @@ func TestTypes(t *testing.T) {
 	defaultErr := fmt.Errorf("this is an %s", "error")
 
 	for i, tt := range tests {
-		err := Wrap(defaultErr, "prefix").WithTags(tt.tags...).WithTypes(tt.types...)
+		err := Wrap(defaultErr, "prefix").AddTags(tt.tags...).AddTypes(tt.types...)
 		if !strings.HasSuffix(err.Error(), tt.err) {
 			t.Fatalf("IDX: %d want %s got %s", i, tt.err, err.Error())
 		}
@@ -86,7 +86,7 @@ func TestHasType(t *testing.T) {
 	defaultErr := fmt.Errorf("this is an %s", "error")
 
 	for i, tt := range tests {
-		err := Wrap(defaultErr, "prefix").WithTypes(tt.types...)
+		err := Wrap(defaultErr, "prefix").AddTypes(tt.types...)
 		if !HasType(err, tt.typ) {
 			t.Fatalf("IDX: %d want %t got %t", i, true, false)
 		}
@@ -122,7 +122,7 @@ func TestCause2(t *testing.T) {
 
 func TestHelpers(t *testing.T) {
 	fn := func(w Chain, err error) (cont bool) {
-		w.WithTypes("Test").WithTags(T("test", "tag")).WithTag("foo", "bar")
+		w.AddTypes("Test").AddTags(T("test", "tag")).AddTag("foo", "bar")
 		return false
 	}
 	RegisterHelper(fn)
@@ -134,7 +134,7 @@ func TestHelpers(t *testing.T) {
 }
 
 func TestLookupTag(t *testing.T) {
-	err := Wrap(io.EOF, "prefix").WithTag("Key", "Value")
+	err := Wrap(io.EOF, "prefix").AddTag("Key", "Value")
 	if LookupTag(err, "Key").(string) != "Value" {
 		t.Fatalf("want %s got %v", "Value", LookupTag(err, "Key"))
 	}

helpers/awserrors/awserrors.go

@@ -9,22 +9,22 @@ import (
 func AWSErrors(c errors.Chain, err error) (cont bool) {
 	switch e := err.(type) {
 	case awserr.BatchError:
-		c.WithTypes("Transient", "Batch").WithTags(errors.T("aws_error_code", e.Code()))
+		c.AddTypes("Transient", "Batch").AddTags(errors.T("aws_error_code", e.Code()))
 		return
 
 	case awserr.BatchedErrors:
-		c.WithTypes("Transient", "Batch")
+		c.AddTypes("Transient", "Batch")
 		return
 
 	case awserr.RequestFailure:
-		c.WithTypes("Transient", "Request").WithTags(
+		c.AddTypes("Transient", "Request").AddTags(
 			errors.T("status_code", e.StatusCode()),
 			errors.T("request_id", e.RequestID()),
 		)
 		return
 
 	case awserr.Error:
-		c.WithTypes("General", "Error").WithTags(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.WithTypes("io")
+		c.AddTypes("io")
 		return
 	case io.ErrClosedPipe:
-		c.WithTypes("Permanent", "io")
+		c.AddTypes("Permanent", "io")
 		return
 	case io.ErrNoProgress:
-		c.WithTypes("Permanent", "io")
+		c.AddTypes("Permanent", "io")
 		return
 	case io.ErrShortBuffer:
-		c.WithTypes("Permanent", "io")
+		c.AddTypes("Permanent", "io")
 		return
 	case io.ErrShortWrite:
-		c.WithTypes("Permanent", "io")
+		c.AddTypes("Permanent", "io")
 		return
 	case io.ErrUnexpectedEOF:
-		c.WithTypes("Transient", "io")
+		c.AddTypes("Transient", "io")
 		return
 	}
 	return true

helpers/neterrors/neterrors.go

@@ -14,7 +14,7 @@ func NETErrors(c errors.Chain, err error) (cont bool) {
 		if e.Temporary() {
 			tp = "Transient"
 		}
-		c.WithTypes(tp, "net").WithTags(
+		c.AddTypes(tp, "net").AddTags(
 			errors.T("addr", e.Addr),
 			errors.T("is_timeout", e.Timeout()),
 			errors.T("is_temporary", e.Temporary()),
@@ -26,7 +26,7 @@ func NETErrors(c errors.Chain, err error) (cont bool) {
 		if e.Temporary() {
 			tp = "Transient"
 		}
-		c.WithTypes(tp, "net").WithTags(
+		c.AddTypes(tp, "net").AddTags(
 			errors.T("name", e.Name),
 			errors.T("server", e.Server),
 			errors.T("is_timeout", e.Timeout()),
@@ -35,7 +35,7 @@ func NETErrors(c errors.Chain, err error) (cont bool) {
 		return false
 
 	case *net.ParseError:
-		c.WithTypes("Permanent", "net").WithTags(
+		c.AddTypes("Permanent", "net").AddTags(
 			errors.T("type", e.Type),
 			errors.T("text", e.Text),
 		)
@@ -46,7 +46,7 @@ func NETErrors(c errors.Chain, err error) (cont bool) {
 		if e.Temporary() {
 			tp = "Transient"
 		}
-		c.WithTypes(tp, "net").WithTags(
+		c.AddTypes(tp, "net").AddTags(
 			errors.T("op", e.Op),
 			errors.T("net", e.Net),
 			errors.T("addr", e.Addr),
@@ -60,15 +60,15 @@ func NETErrors(c errors.Chain, err error) (cont bool) {
 		if e.Temporary() {
 			tp = "Transient"
 		}
-		c.WithTypes(tp, "net").WithTags(
+		c.AddTypes(tp, "net").AddTags(
 			errors.T("is_timeout", e.Timeout()),
 			errors.T("is_temporary", e.Temporary()),
 		)
 	}
 
 	switch err {
 	case net.ErrWriteToConnected:
-		c.WithTypes("Transient", "net")
+		c.AddTypes("Transient", "net")
 		return false
 	}
 	return true