Updates (#14)

Author: Dean Karn

.github/workflows/go.yml

@@ -1,35 +1,45 @@
-name: Lint & Test
-on: [push, pull_request]
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+name: Test
 jobs:
   test:
     strategy:
       matrix:
-        go-version: [1.14.x,1.13.x]
-        platform: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.platform }}
+        go-version: [1.18.x]
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
     steps:
       - name: Install Go
-        uses: actions/setup-go@v1
+        uses: actions/setup-go@v3
         with:
           go-version: ${{ matrix.go-version }}
 
-      - name: Priming Cache
-        uses: actions/cache@v1
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - name: Restore Cache
+        uses: actions/cache@v3
         with:
           path: ~/go/pkg/mod
           key: ${{ runner.os }}-v1-go-${{ hashFiles('**/go.sum') }}
           restore-keys: |
             ${{ runner.os }}-v1-go-
 
-      - name: Checkout code
-        uses: actions/checkout@v2
-
-      - name: Lint
-        if: matrix.platform == 'ubuntu-latest' && matrix.go-version == '1.14.x'
-        run: |
-          export PATH=$PATH:$(go env GOPATH)/bin # temporary fix. See https://github.com/actions/setup-go/issues/14
-          go get -u golang.org/x/lint/golint
-          golint -set_exit_status ./...
-
       - name: Test
-        run: go test ./...
+        run: go test -race ./...
+
+  golangci:
+    name: lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/setup-go@v3
+        with:
+          go-version: 1.18.x
+      - uses: actions/checkout@v3
+      - name: golangci-lint
+        uses: golangci/golangci-lint-action@v3
+        with:
+          version: v1.46.2

CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [5.2.0] - 2022-05-28
+### Added
+- Wrap check for nil errors which will now panic to indicate a larger issue, the caller NOT checking an error value. This caused a panic when trying to print the error if nil error was wrapped.
+
+### Removed
+- Deprecated information in the documentation.
+
+### Changed
+- Updated deps.
+
+
+[Unreleased]: https://github.com/rust-playground/relay-rs/compare/v5.2.0...HEAD
+[5.2.0]: https://github.com/rust-playground/relay-rs/compare/v5.1.1...v5.2.0

Makefile

@@ -3,11 +3,11 @@ GOCMD=GO111MODULE=on go
 linters-install:
 	@golangci-lint --version >/dev/null 2>&1 || { \
 		echo "installing linting tools..."; \
-		curl -sfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh| sh -s v1.21.0; \
+		brew install golangci-lint; \
 	}
 
 lint: linters-install
-	$(PWD)/bin/golangci-lint run
+	@golangci-lint run
 
 test:
 	$(GOCMD) test -cover -race ./...

README.md

@@ -1,6 +1,6 @@
 Package errors
 ============
-![Project status](https://img.shields.io/badge/version-5.1.1-green.svg)
+![Project status](https://img.shields.io/badge/version-5.2.0-green.svg)
 [![Build Status](https://travis-ci.org/go-playground/errors.svg?branch=master)](https://travis-ci.org/go-playground/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://pkg.go.dev/github.com/go-playground/errors/v5)

chain.go

@@ -17,15 +17,15 @@ var (
 )
 
 // T is a shortcut to make a Tag
-func T(key string, value interface{}) Tag {
+func T(key string, value any) Tag {
 	return Tag{Key: key, Value: value}
 }
 
 // Tag contains a single key value combination
 // to be attached to your error
 type Tag struct {
 	Key   string
-	Value interface{}
+	Value any
 }
 
 func newLink(err error, prefix string, skipFrames int) *Link {
@@ -42,16 +42,7 @@ type Chain []*Link
 
 // Error returns the formatted error string
 func (c Chain) Error() string {
-	//if errFormatFn != nil {
 	return errFormatFn(c)
-	//}
-	//b := make([]byte, 0, len(c)*192)
-	//
-	//for i := 0; i < len(c); i++ {
-	//	b = c[i].formatError(b)
-	//	b = append(b, '\n')
-	//}
-	//return unsafeext.BytesToString(b[:len(b)-1])
 }
 
 // Link contains a single error entry, unless it's the top level error, in
@@ -186,7 +177,7 @@ func (c Chain) AddTags(tags ...Tag) Chain {
 }
 
 // AddTag allows the addition of a single tag
-func (c Chain) AddTag(key string, value interface{}) Chain {
+func (c Chain) AddTag(key string, value any) Chain {
 	return c.AddTags(Tag{Key: key, Value: value})
 }
 
@@ -202,7 +193,7 @@ func (c Chain) Wrap(prefix string) Chain {
 	return wrap(c, prefix, 3)
 }
 
-// Unwrap returns the result of calling the Unwrap method on err, if err's
+// Unwrap returns the result of calling the Unwrap method on an error, if the errors
 // type contains an Unwrap method returning error.
 // Otherwise, Unwrap returns nil.
 //
@@ -217,31 +208,28 @@ func (c Chain) Unwrap() error {
 	return c[:len(c)-1]
 }
 
-// Is reports whether any error in err's chain matches target.
-//
-// This is here to help make it a drop in replacement to the std error handler, I highly recommend using
-// Cause + switch statement instead.
+// Is reports whether any error in error chain matches target.
 func (c Chain) Is(target error) bool {
 	return stderrors.Is(c[len(c)-1].Err, target)
 }
 
-// As finds the first error in err's chain that matches target, and if so, sets
+// As finds the first error in the error chain that matches target, and if so, sets
 // target to that error value and returns true. Otherwise, it returns false.
 //
 // The chain consists of err itself followed by the sequence of errors obtained by
 // repeatedly calling Unwrap.
 //
 // An error matches target if the error's concrete value is assignable to the value
-// pointed to by target, or if the error has a method As(interface{}) bool such that
+// pointed to by target, or if the error has a method As(any) bool such that
 // As(target) returns true. In the latter case, the As method is responsible for
 // setting target.
 //
-// An error type might provide an As method so it can be treated as if it were a
-// a different error type.
+// An error type might provide an As method, so it can be treated as if it were a
+// different error type.
 //
 // As panics if target is not a non-nil pointer to either a type that implements
 // error, or to any interface type.
-func (c Chain) As(target interface{}) bool {
+func (c Chain) As(target any) bool {
 	return stderrors.As(c[len(c)-1].Err, target)
 }
 

errors.go

@@ -9,7 +9,7 @@ import (
 
 type unwrap interface{ Unwrap() error }
 type is interface{ Is(error) bool }
-type as interface{ As(interface{}) bool }
+type as interface{ As(any) bool }
 
 // ErrorFormatFn represents the error formatting function for a Chain of errors.
 type ErrorFormatFn func(Chain) string
@@ -42,8 +42,8 @@ func New(s string) Chain {
 }
 
 // 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 {
+// it also accepts a variadic for optional message formatting.
+func Newf(format string, a ...any) Chain {
 	return wrap(fmt.Errorf(format, a...), "", 3)
 }
 
@@ -55,8 +55,8 @@ func Wrap(err error, prefix string) Chain {
 
 // 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 {
+// it also accepts a variadic for prefix formatting.
+func Wrapf(err error, prefix string, a ...any) Chain {
 	return wrap(err, fmt.Sprintf(prefix, a...), 3)
 }
 
@@ -67,6 +67,9 @@ func WrapSkipFrames(err error, prefix string, n uint) Chain {
 }
 
 func wrap(err error, prefix string, skipFrames int) (c Chain) {
+	if err == nil {
+		panic("errors: Wrap|Wrapf called with nil error")
+	}
 	var ok bool
 	if c, ok = err.(Chain); ok {
 		c = append(c, newLink(err, prefix, skipFrames))
@@ -81,7 +84,7 @@ func wrap(err error, prefix string, skipFrames int) (c Chain) {
 	return
 }
 
-// Cause extracts and returns the root wrapped error (the naked error with no additional information
+// Cause extracts and returns the root wrapped error (the naked error with no additional information)
 func Cause(err error) error {
 	for {
 		switch t := err.(type) {
@@ -121,8 +124,8 @@ func HasType(err error, typ string) bool {
 	}
 }
 
-// LookupTag recursively searches for the provided tag and returns it's value or nil
-func LookupTag(err error, key string) interface{} {
+// LookupTag recursively searches for the provided tag and returns its value or nil
+func LookupTag(err error, key string) any {
 	for {
 		switch t := err.(type) {
 		case Chain:
@@ -143,17 +146,17 @@ func LookupTag(err error, key string) interface{} {
 	}
 }
 
-// Is is to allow this library to be a drop-in replacement to the std library.
+// Is allows this library to be a drop-in replacement to the std library.
 //
-// Is reports whether any error in err's chain matches target.
+// Is reports whether any error in the error chain matches target.
 //
 // The chain consists of err itself followed by the sequence of errors obtained by
 // repeatedly calling Unwrap.
 //
 // An error is considered to match a target if it is equal to that target or if
 // it implements a method Is(error) bool such that Is(target) returns true.
 //
-// An error type might provide an Is method so it can be treated as equivalent
+// An error type might provide an Is method, so it can be treated as equivalent
 // to an existing error. For example, if MyError defines
 //
 //	func (m MyError) Is(target error) bool { return target == os.ErrExist }
@@ -166,22 +169,22 @@ func Is(err, target error) bool {
 
 // As is to allow this library to be a drop-in replacement to the std library.
 //
-// As finds the first error in err's chain that matches target, and if so, sets
+// As finds the first error in the error chain that matches target, and if so, sets
 // target to that error value and returns true. Otherwise, it returns false.
 //
 // The chain consists of err itself followed by the sequence of errors obtained by
 // repeatedly calling Unwrap.
 //
 // An error matches target if the error's concrete value is assignable to the value
-// pointed to by target, or if the error has a method As(interface{}) bool such that
+// pointed to by target, or if the error has a method As(any) bool such that
 // As(target) returns true. In the latter case, the As method is responsible for
 // setting target.
 //
-// An error type might provide an As method so it can be treated as if it were a
+// An error type might provide an As method, so it can be treated as if it were
 // a different error type.
 //
 // As panics if target is not a non-nil pointer to either a type that implements
 // error, or to any interface type.
-func As(err error, target interface{}) bool {
-	return stderrors.As(err, target)
+func As(err error, target any) bool {
+	return stderrors.As(err, &target)
 }

errors_test.go

@@ -70,10 +70,15 @@ func TestWrap(t *testing.T) {
 func TestUnwrap(t *testing.T) {
 	defaultErr := stderrors.New("this is an error")
 	err := fmt.Errorf("std wrapped: %w", defaultErr)
+	assertError(t, err)
 	err = Wrap(defaultErr, "prefix")
+	assertError(t, err)
 	err = Wrap(err, "prefix2")
+	assertError(t, err)
 	err = fmt.Errorf("wrapping Chain: %w", err)
+	assertError(t, err)
 	err = fmt.Errorf("wrapping err again: %w", err)
+	assertError(t, err)
 	err = Wrap(err, "wrapping std with chain")
 
 	for {
@@ -92,6 +97,12 @@ func TestUnwrap(t *testing.T) {
 	}
 }
 
+func assertError(t *testing.T, err error) {
+	if err == nil {
+		t.Fatal("err is nil")
+	}
+}
+
 func TestTags(t *testing.T) {
 	tests := []struct {
 		err  string
@@ -195,10 +206,15 @@ func TestCause2(t *testing.T) {
 func TestCauseStdErrorsMixed(t *testing.T) {
 	defaultErr := stderrors.New("this is an error")
 	err := fmt.Errorf("std wrapped: %w", defaultErr)
+	assertError(t, err)
 	err = Wrap(defaultErr, "prefix")
+	assertError(t, err)
 	err = Wrap(err, "prefix2")
+	assertError(t, err)
 	err = fmt.Errorf("wrapping Chain: %w", err)
+	assertError(t, err)
 	err = fmt.Errorf("wrapping err again: %w", err)
+	assertError(t, err)
 	err = Wrap(err, "wrapping std with chain")
 	cause := Cause(err)
 	expect := defaultErr.Error()
@@ -228,7 +244,7 @@ func TestLookupTag(t *testing.T) {
 		name  string
 		err   error
 		key   string
-		value interface{}
+		value any
 	}{
 		{
 			name: "basic wrap",
@@ -257,10 +273,15 @@ func TestLookupTag(t *testing.T) {
 func TestIs(t *testing.T) {
 	defaultErr := io.EOF
 	err := fmt.Errorf("std wrapped: %w", defaultErr)
+	assertError(t, err)
 	err = Wrap(defaultErr, "prefix")
+	assertError(t, err)
 	err = Wrap(err, "prefix2")
+	assertError(t, err)
 	err = fmt.Errorf("wrapping Chain: %w", err)
+	assertError(t, err)
 	err = fmt.Errorf("wrapping err again: %w", err)
+	assertError(t, err)
 	err = Wrap(err, "wrapping std with chain")
 	if !Is(err, io.EOF) {
 		t.Fatal("want true got false")
@@ -278,10 +299,15 @@ func (e *myErrorType) Error() string {
 func TestAs(t *testing.T) {
 	defaultErr := &myErrorType{msg: "my error type"}
 	err := fmt.Errorf("std wrapped: %w", defaultErr)
+	assertError(t, err)
 	err = Wrap(defaultErr, "prefix")
+	assertError(t, err)
 	err = Wrap(err, "prefix2")
+	assertError(t, err)
 	err = fmt.Errorf("wrapping Chain: %w", err)
+	assertError(t, err)
 	err = fmt.Errorf("wrapping err again: %w", err)
+	assertError(t, err)
 	err = Wrap(err, "wrapping std with chain")
 
 	var myErr *myErrorType