Merge pull request #638 from cszczepaniak/cs/remove_pkg_errors

Remove github.com/pkg/errors

cmd/mockery.go

@@ -2,6 +2,7 @@ package cmd
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -11,14 +12,14 @@ import (
 
 	"github.com/chigopher/pathlib"
 	"github.com/mitchellh/go-homedir"
-	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
 	"github.com/rs/zerolog/log"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/vektra/mockery/v2/pkg"
 	"github.com/vektra/mockery/v2/pkg/config"
 	"github.com/vektra/mockery/v2/pkg/logging"
+	"github.com/vektra/mockery/v2/pkg/stackerr"
 	"golang.org/x/tools/go/packages"
 )
 
@@ -90,18 +91,12 @@ func NewRootCmd() *cobra.Command {
 	return cmd
 }
 
-type stackTracer interface {
-	StackTrace() errors.StackTrace
-}
-
 func printStackTrace(e error) {
 	fmt.Printf("%v\n", e)
-	if err, ok := e.(stackTracer); ok {
-		for _, f := range err.StackTrace() {
-			fmt.Printf("%+s:%d\n", f, f)
-		}
-	}
 
+	if stack, ok := stackerr.GetStack(e); ok {
+		fmt.Printf("%+s\n", stack)
+	}
 }
 
 // Execute executes the cobra CLI workflow
@@ -180,7 +175,7 @@ func GetRootAppFromViper(v *viper.Viper) (*RootApp, error) {
 	r := &RootApp{}
 	config, err := config.NewConfigFromViper(v)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to get config")
+		return nil, stackerr.NewStackErrf(err, "failed to get config")
 	}
 	r.Config = *config
 	return r, nil
@@ -325,7 +320,7 @@ func (r *RootApp) Run() error {
 		if r.Config.Profile != "" {
 			f, err := os.Create(r.Config.Profile)
 			if err != nil {
-				return errors.Wrapf(err, "Failed to create profile file")
+				return stackerr.NewStackErrf(err, "Failed to create profile file")
 			}
 
 			if err := pprof.StartCPUProfile(f); err != nil {

cmd/showconfig.go

@@ -6,11 +6,11 @@ import (
 	"io"
 	"os"
 
-	"github.com/pkg/errors"
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/vektra/mockery/v2/pkg/config"
 	"github.com/vektra/mockery/v2/pkg/logging"
+	"github.com/vektra/mockery/v2/pkg/stackerr"
 	"gopkg.in/yaml.v2"
 )
 
@@ -35,7 +35,7 @@ func showConfig(
 	ctx := context.Background()
 	config, err := config.NewConfigFromViper(v)
 	if err != nil {
-		return errors.Wrapf(err, "failed to unmarshal config")
+		return stackerr.NewStackErrf(err, "failed to unmarshal config")
 	}
 	if err := config.Initialize(ctx); err != nil {
 		return err
@@ -46,7 +46,7 @@ func showConfig(
 	}
 	out, err := yaml.Marshal(cfgMap)
 	if err != nil {
-		return errors.Wrapf(err, "Failed to marshal yaml")
+		return stackerr.NewStackErrf(err, "failed to marshal yaml")
 	}
 	log, err := logging.GetLogger(config.LogLevel)
 	if err != nil {

go.mod

@@ -9,7 +9,6 @@ require (
 	github.com/jinzhu/copier v0.3.5
 	github.com/mitchellh/go-homedir v1.1.0
 	github.com/mitchellh/mapstructure v1.5.0
-	github.com/pkg/errors v0.9.1
 	github.com/rs/zerolog v1.29.0
 	github.com/spf13/cobra v1.6.1
 	github.com/spf13/viper v1.15.0

go.sum

@@ -166,7 +166,6 @@ github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLA
 github.com/pelletier/go-toml/v2 v2.0.6 h1:nrzqCb7j9cDFj2coyLNLaZuJTLjWjlaz6nvTvIwycIU=
 github.com/pelletier/go-toml/v2 v2.0.6/go.mod h1:eumQOmlWiOPt5WriQQqoM5y18pDHwha2N+QD+EUNTek=
 github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

pkg/config/config.go

@@ -3,6 +3,7 @@ package config
 import (
 	"bufio"
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"reflect"
@@ -11,10 +12,10 @@ import (
 	"github.com/chigopher/pathlib"
 	"github.com/jinzhu/copier"
 	"github.com/mitchellh/mapstructure"
-	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
 	"github.com/spf13/viper"
 	"github.com/vektra/mockery/v2/pkg/logging"
+	"github.com/vektra/mockery/v2/pkg/stackerr"
 	"golang.org/x/tools/go/packages"
 	"gopkg.in/yaml.v3"
 )
@@ -137,11 +138,11 @@ func (c *Config) CfgAsMap(ctx context.Context) (map[string]any, error) {
 				log.Debug().Msg("config file doesn't exist, returning empty config map")
 				return map[string]any{}, nil
 			}
-			return nil, errors.Wrapf(err, "failed to read file: %v", configPath)
+			return nil, stackerr.NewStackErrf(err, "failed to read file: %v", configPath)
 		}
 
 		if err := yaml.Unmarshal(fileBytes, newCfg); err != nil {
-			return nil, errors.Wrapf(err, "failed to unmarshal yaml")
+			return nil, stackerr.NewStackErrf(err, "failed to unmarshal yaml")
 		}
 		c._cfgAsMap = newCfg
 	}
@@ -223,7 +224,7 @@ func (c *Config) GetPackageConfig(ctx context.Context, packageName string) (*Con
 
 	configMap, err := c.getPackageConfigMap(ctx, packageName)
 	if err != nil {
-		return nil, errors.Wrapf(err, "unable to get map config for package")
+		return nil, stackerr.NewStackErrf(err, "unable to get map config for package")
 	}
 
 	configSection, ok := configMap["config"]
@@ -234,7 +235,7 @@ func (c *Config) GetPackageConfig(ctx context.Context, packageName string) (*Con
 
 	decoder, err := c.getDecoder(pkgConfigTyped)
 	if err != nil {
-		return nil, errors.Wrap(err, "failed to get decoder")
+		return nil, stackerr.NewStackErrf(err, "failed to get decoder")
 	}
 	if err := decoder.Decode(configSection); err != nil {
 		return nil, err
@@ -290,7 +291,7 @@ func (c *Config) GetInterfaceConfig(ctx context.Context, packageName string, int
 
 	pkgConfig, err := c.GetPackageConfig(ctx, packageName)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to get config for package when iterating over interface")
+		return nil, stackerr.NewStackErrf(err, "failed to get config for package when iterating over interface")
 	}
 	interfacesSection, err := c.getInterfacesSection(ctx, packageName)
 	if err != nil {
@@ -300,7 +301,7 @@ func (c *Config) GetInterfaceConfig(ctx context.Context, packageName string, int
 	// Copy the package-level config to our interface-level config
 	pkgConfigCopy := reflect.New(reflect.ValueOf(pkgConfig).Elem().Type()).Interface()
 	if err := copier.Copy(pkgConfigCopy, pkgConfig); err != nil {
-		return nil, errors.Wrap(err, "failed to create a copy of package config")
+		return nil, stackerr.NewStackErrf(err, "failed to create a copy of package config")
 	}
 	baseConfigTyped := pkgConfigCopy.(*Config)
 
@@ -320,7 +321,7 @@ func (c *Config) GetInterfaceConfig(ctx context.Context, packageName string, int
 		}
 		msgString := "bad type provided for interface config"
 		log.Error().Msgf(msgString)
-		return nil, errors.New(msgString)
+		return nil, stackerr.NewStackErr(errors.New(msgString))
 	}
 
 	configSection, ok := interfaceSectionTyped["config"]
@@ -333,10 +334,10 @@ func (c *Config) GetInterfaceConfig(ctx context.Context, packageName string, int
 		// `configs` section.
 		decoder, err := c.getDecoder(baseConfigTyped)
 		if err != nil {
-			return nil, errors.Wrapf(err, "unable to create mapstructure decoder")
+			return nil, stackerr.NewStackErrf(err, "unable to create mapstructure decoder")
 		}
 		if err := decoder.Decode(configSection); err != nil {
-			return nil, errors.Wrapf(err, "unable to decode interface config")
+			return nil, stackerr.NewStackErrf(err, "unable to decode interface config")
 		}
 	} else {
 		log.Debug().Msg("config section for interface doesn't exist")
@@ -350,16 +351,16 @@ func (c *Config) GetInterfaceConfig(ctx context.Context, packageName string, int
 			// Create a copy of the package-level config
 			currentInterfaceConfig := reflect.New(reflect.ValueOf(baseConfigTyped).Elem().Type()).Interface()
 			if err := copier.Copy(currentInterfaceConfig, baseConfigTyped); err != nil {
-				return nil, errors.Wrap(err, "failed to copy package config")
+				return nil, stackerr.NewStackErrf(err, "failed to copy package config")
 			}
 
 			// decode the new values into the struct
 			decoder, err := c.getDecoder(currentInterfaceConfig)
 			if err != nil {
-				return nil, errors.Wrapf(err, "unable to create mapstructure decoder")
+				return nil, stackerr.NewStackErrf(err, "unable to create mapstructure decoder")
 			}
 			if err := decoder.Decode(configMap); err != nil {
-				return nil, errors.Wrapf(err, "unable to decode interface config")
+				return nil, stackerr.NewStackErrf(err, "unable to decode interface config")
 			}
 
 			configs = append(configs, currentInterfaceConfig.(*Config))

pkg/logging/logging.go

@@ -1,12 +1,13 @@
 package logging
 
 import (
+	"errors"
 	"os"
 	"runtime/debug"
 	"time"
 
-	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
+	"github.com/vektra/mockery/v2/pkg/stackerr"
 	"golang.org/x/term"
 )
 
@@ -47,7 +48,7 @@ func (t timeHook) Run(e *zerolog.Event, level zerolog.Level, msg string) {
 func GetLogger(levelStr string) (zerolog.Logger, error) {
 	level, err := zerolog.ParseLevel(levelStr)
 	if err != nil {
-		return zerolog.Logger{}, errors.Wrapf(err, "Couldn't parse log level")
+		return zerolog.Logger{}, stackerr.NewStackErrf(err, "Couldn't parse log level")
 	}
 	out := os.Stderr
 	writer := zerolog.ConsoleWriter{

pkg/outputter.go

@@ -3,6 +3,7 @@ package pkg
 import (
 	"bytes"
 	"context"
+	"errors"
 	"fmt"
 	"go/ast"
 	"io"
@@ -14,11 +15,11 @@ import (
 
 	"github.com/chigopher/pathlib"
 	"github.com/iancoleman/strcase"
-	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
 
 	"github.com/vektra/mockery/v2/pkg/config"
 	"github.com/vektra/mockery/v2/pkg/logging"
+	"github.com/vektra/mockery/v2/pkg/stackerr"
 )
 
 var ErrInfiniteLoop = fmt.Errorf("infintie loop in template variables detected")
@@ -346,18 +347,18 @@ func (m *Outputter) Generate(ctx context.Context, iface *Interface) error {
 
 		outputPath := pathlib.NewPath(interfaceConfig.Dir).Join(interfaceConfig.FileName)
 		if err := outputPath.Parent().MkdirAll(); err != nil {
-			return errors.Wrapf(err, "failed to mkdir parents of: %v", outputPath)
+			return stackerr.NewStackErrf(err, "failed to mkdir parents of: %v", outputPath)
 		}
 
 		fileLog := log.With().Stringer(logging.LogKeyFile, outputPath).Logger()
 		fileLog.Info().Msg("writing to file")
 		file, err := outputPath.OpenFile(os.O_RDWR | os.O_CREATE | os.O_TRUNC)
 		if err != nil {
-			return errors.Wrapf(err, "failed to open output file for mock: %v", outputPath)
+			return stackerr.NewStackErrf(err, "failed to open output file for mock: %v", outputPath)
 		}
 		defer file.Close()
 		if err := generator.Write(file); err != nil {
-			return errors.Wrapf(err, "failed to write to file")
+			return stackerr.NewStackErrf(err, "failed to write to file")
 		}
 	}
 	return nil

pkg/stackerr/stackerr.go

@@ -0,0 +1,47 @@
+package stackerr
+
+import (
+	"errors"
+	"fmt"
+	"runtime/debug"
+)
+
+type StackErr struct {
+	cause error
+	stack []byte
+}
+
+func NewStackErr(cause error) error {
+	return StackErr{
+		cause: cause,
+		stack: debug.Stack(),
+	}
+}
+
+func NewStackErrf(cause error, f string, args ...any) error {
+	msg := fmt.Sprintf(f, args...)
+	cause = fmt.Errorf(msg+": %w", cause)
+	return NewStackErr(cause)
+}
+
+func (se StackErr) Error() string {
+	return se.cause.Error()
+}
+
+func (se StackErr) Unwrap() error {
+	return se.cause
+}
+
+func (se StackErr) Stack() []byte {
+	return se.stack
+}
+
+func GetStack(err error) ([]byte, bool) {
+	var s interface {
+		Stack() []byte
+	}
+	if errors.As(err, &s) {
+		return s.Stack(), true
+	}
+	return nil, false
+}

pkg/stackerr/stackerr_test.go

@@ -0,0 +1,43 @@
+package stackerr
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStackErr(t *testing.T) {
+	err := assert.AnError
+
+	s, ok := GetStack(err)
+	assert.False(t, ok)
+	assert.Empty(t, s)
+
+	err = NewStackErr(err)
+	assert.Equal(t, assert.AnError.Error(), err.Error())
+
+	s, ok = GetStack(err)
+	assert.True(t, ok)
+	assert.NotEmpty(t, s)
+
+	err = NewStackErr(fmt.Errorf("wrapped error can still get stack: %w", err))
+	s, ok = GetStack(err)
+	assert.True(t, ok)
+	assert.NotEmpty(t, s)
+}
+
+func TestStackErrf(t *testing.T) {
+	err := assert.AnError
+
+	s, ok := GetStack(err)
+	assert.False(t, ok)
+	assert.Empty(t, s)
+
+	err = NewStackErrf(err, "error message %d %s", 1, "a")
+	assert.Equal(t, "error message 1 a: "+assert.AnError.Error(), err.Error())
+
+	s, ok = GetStack(err)
+	assert.True(t, ok)
+	assert.NotEmpty(t, s)
+}