From 69ba90925b2cfe23756d4632e682fc9b10f61f93 Mon Sep 17 00:00:00 2001
From: Paul van Santen <pvansanten@transip.nl>
Date: Mon, 11 Jan 2021 11:46:59 +0100
Subject: [PATCH] Use go error wrapping for easier error handling

---
 archiver.go | 20 +++++++++---------
 rar.go      | 32 ++++++++++++++--------------
 tar.go      | 60 ++++++++++++++++++++++++++---------------------------
 zip.go      | 56 ++++++++++++++++++++++++-------------------------
 4 files changed, 84 insertions(+), 84 deletions(-)

diff --git a/archiver.go b/archiver.go
index b09699d6..1a1b5bc8 100644
--- a/archiver.go
+++ b/archiver.go
@@ -281,7 +281,7 @@ func fileExists(name string) bool {
 func mkdir(dirPath string, dirMode os.FileMode) error {
 	err := os.MkdirAll(dirPath, dirMode)
 	if err != nil {
-		return fmt.Errorf("%s: making directory: %v", dirPath, err)
+		return fmt.Errorf("%s: making directory: %w", dirPath, err)
 	}
 	return nil
 }
@@ -289,23 +289,23 @@ func mkdir(dirPath string, dirMode os.FileMode) error {
 func writeNewFile(fpath string, in io.Reader, fm os.FileMode) error {
 	err := os.MkdirAll(filepath.Dir(fpath), 0755)
 	if err != nil {
-		return fmt.Errorf("%s: making directory for file: %v", fpath, err)
+		return fmt.Errorf("%s: making directory for file: %w", fpath, err)
 	}
 
 	out, err := os.Create(fpath)
 	if err != nil {
-		return fmt.Errorf("%s: creating new file: %v", fpath, err)
+		return fmt.Errorf("%s: creating new file: %w", fpath, err)
 	}
 	defer out.Close()
 
 	err = out.Chmod(fm)
 	if err != nil && runtime.GOOS != "windows" {
-		return fmt.Errorf("%s: changing file mode: %v", fpath, err)
+		return fmt.Errorf("%s: changing file mode: %w", fpath, err)
 	}
 
 	_, err = io.Copy(out, in)
 	if err != nil {
-		return fmt.Errorf("%s: writing file: %v", fpath, err)
+		return fmt.Errorf("%s: writing file: %w", fpath, err)
 	}
 	return nil
 }
@@ -313,7 +313,7 @@ func writeNewFile(fpath string, in io.Reader, fm os.FileMode) error {
 func writeNewSymbolicLink(fpath string, target string) error {
 	err := os.MkdirAll(filepath.Dir(fpath), 0755)
 	if err != nil {
-		return fmt.Errorf("%s: making directory for file: %v", fpath, err)
+		return fmt.Errorf("%s: making directory for file: %w", fpath, err)
 	}
 
 	_, err = os.Lstat(fpath)
@@ -326,7 +326,7 @@ func writeNewSymbolicLink(fpath string, target string) error {
 
 	err = os.Symlink(target, fpath)
 	if err != nil {
-		return fmt.Errorf("%s: making symbolic link for: %v", fpath, err)
+		return fmt.Errorf("%s: making symbolic link for: %w", fpath, err)
 	}
 	return nil
 }
@@ -334,7 +334,7 @@ func writeNewSymbolicLink(fpath string, target string) error {
 func writeNewHardLink(fpath string, target string) error {
 	err := os.MkdirAll(filepath.Dir(fpath), 0755)
 	if err != nil {
-		return fmt.Errorf("%s: making directory for file: %v", fpath, err)
+		return fmt.Errorf("%s: making directory for file: %w", fpath, err)
 	}
 
 	_, err = os.Lstat(fpath)
@@ -347,7 +347,7 @@ func writeNewHardLink(fpath string, target string) error {
 
 	err = os.Link(target, fpath)
 	if err != nil {
-		return fmt.Errorf("%s: making hard link for: %v", fpath, err)
+		return fmt.Errorf("%s: making hard link for: %w", fpath, err)
 	}
 	return nil
 }
@@ -489,7 +489,7 @@ func ByHeader(input io.ReadSeeker) (Unarchiver, error) {
 	for _, m := range matchers {
 		ok, err := m.Match(input)
 		if err != nil {
-			return nil, fmt.Errorf("matching on format %s: %v", m, err)
+			return nil, fmt.Errorf("matching on format %s: %w", m, err)
 		}
 		if ok {
 			matcher = m
diff --git a/rar.go b/rar.go
index 56c2a3e3..9334610f 100644
--- a/rar.go
+++ b/rar.go
@@ -82,7 +82,7 @@ func (r *Rar) Unarchive(source, destination string) error {
 	if !fileExists(destination) && r.MkdirAll {
 		err := mkdir(destination, 0755)
 		if err != nil {
-			return fmt.Errorf("preparing destination: %v", err)
+			return fmt.Errorf("preparing destination: %w", err)
 		}
 	}
 
@@ -93,13 +93,13 @@ func (r *Rar) Unarchive(source, destination string) error {
 		var err error
 		destination, err = r.addTopLevelFolder(source, destination)
 		if err != nil {
-			return fmt.Errorf("scanning source archive: %v", err)
+			return fmt.Errorf("scanning source archive: %w", err)
 		}
 	}
 
 	err := r.OpenFile(source)
 	if err != nil {
-		return fmt.Errorf("opening rar archive for reading: %v", err)
+		return fmt.Errorf("opening rar archive for reading: %w", err)
 	}
 	defer r.Close()
 
@@ -113,7 +113,7 @@ func (r *Rar) Unarchive(source, destination string) error {
 				log.Printf("[ERROR] Reading file in rar archive: %v", err)
 				continue
 			}
-			return fmt.Errorf("reading file in rar archive: %v", err)
+			return fmt.Errorf("reading file in rar archive: %w", err)
 		}
 	}
 
@@ -127,13 +127,13 @@ func (r *Rar) Unarchive(source, destination string) error {
 func (r *Rar) addTopLevelFolder(sourceArchive, destination string) (string, error) {
 	file, err := os.Open(sourceArchive)
 	if err != nil {
-		return "", fmt.Errorf("opening source archive: %v", err)
+		return "", fmt.Errorf("opening source archive: %w", err)
 	}
 	defer file.Close()
 
 	rc, err := rardecode.NewReader(file, r.Password)
 	if err != nil {
-		return "", fmt.Errorf("creating archive reader: %v", err)
+		return "", fmt.Errorf("creating archive reader: %w", err)
 	}
 
 	var files []string
@@ -143,7 +143,7 @@ func (r *Rar) addTopLevelFolder(sourceArchive, destination string) (string, erro
 			break
 		}
 		if err != nil {
-			return "", fmt.Errorf("scanning tarball's file listing: %v", err)
+			return "", fmt.Errorf("scanning tarball's file listing: %w", err)
 		}
 		files = append(files, hdr.Name)
 	}
@@ -201,12 +201,12 @@ func (r *Rar) unrarFile(f File, to string) error {
 		if fileExists("testdata") {
 			err := os.Chmod(to, hdr.Mode())
 			if err != nil {
-				return fmt.Errorf("changing dir mode: %v", err)
+				return fmt.Errorf("changing dir mode: %w", err)
 			}
 		} else {
 			err := mkdir(to, hdr.Mode())
 			if err != nil {
-				return fmt.Errorf("making directories: %v", err)
+				return fmt.Errorf("making directories: %w", err)
 			}
 		}
 		return nil
@@ -216,7 +216,7 @@ func (r *Rar) unrarFile(f File, to string) error {
 	// create their folders before writing the file
 	err := mkdir(filepath.Dir(to), 0755)
 	if err != nil {
-		return fmt.Errorf("making parent directories: %v", err)
+		return fmt.Errorf("making parent directories: %w", err)
 	}
 
 	if (hdr.Mode() & os.ModeSymlink) != 0 {
@@ -294,13 +294,13 @@ func (r *Rar) Close() error {
 func (r *Rar) Walk(archive string, walkFn WalkFunc) error {
 	file, err := os.Open(archive)
 	if err != nil {
-		return fmt.Errorf("opening archive file: %v", err)
+		return fmt.Errorf("opening archive file: %w", err)
 	}
 	defer file.Close()
 
 	err = r.Open(file, 0)
 	if err != nil {
-		return fmt.Errorf("opening archive: %v", err)
+		return fmt.Errorf("opening archive: %w", err)
 	}
 	defer r.Close()
 
@@ -314,7 +314,7 @@ func (r *Rar) Walk(archive string, walkFn WalkFunc) error {
 				log.Printf("[ERROR] Opening next file: %v", err)
 				continue
 			}
-			return fmt.Errorf("opening next file: %v", err)
+			return fmt.Errorf("opening next file: %w", err)
 		}
 		err = walkFn(f)
 		if err != nil {
@@ -325,7 +325,7 @@ func (r *Rar) Walk(archive string, walkFn WalkFunc) error {
 				log.Printf("[ERROR] Walking %s: %v", f.Name(), err)
 				continue
 			}
-			return fmt.Errorf("walking %s: %v", f.Name(), err)
+			return fmt.Errorf("walking %s: %w", f.Name(), err)
 		}
 	}
 
@@ -364,13 +364,13 @@ func (r *Rar) Extract(source, target, destination string) error {
 			// build the filename we will extract to
 			end, err := filepath.Rel(targetDirPath, th.Name)
 			if err != nil {
-				return fmt.Errorf("relativizing paths: %v", err)
+				return fmt.Errorf("relativizing paths: %w", err)
 			}
 			joined := filepath.Join(destination, end)
 
 			err = r.unrarFile(f, joined)
 			if err != nil {
-				return fmt.Errorf("extracting file %s: %v", th.Name, err)
+				return fmt.Errorf("extracting file %s: %w", th.Name, err)
 			}
 
 			// if our target was not a directory, stop walk
diff --git a/tar.go b/tar.go
index 60c58fd1..2f83626f 100644
--- a/tar.go
+++ b/tar.go
@@ -83,7 +83,7 @@ func (*Tar) CheckPath(to, filename string) error {
 func (t *Tar) Archive(sources []string, destination string) error {
 	err := t.CheckExt(destination)
 	if t.writerWrapFn == nil && err != nil {
-		return fmt.Errorf("checking extension: %v", err)
+		return fmt.Errorf("checking extension: %w", err)
 	}
 	if !t.OverwriteExisting && fileExists(destination) {
 		return fmt.Errorf("file already exists: %s", destination)
@@ -95,19 +95,19 @@ func (t *Tar) Archive(sources []string, destination string) error {
 	if t.MkdirAll && !fileExists(destDir) {
 		err := mkdir(destDir, 0755)
 		if err != nil {
-			return fmt.Errorf("making folder for destination: %v", err)
+			return fmt.Errorf("making folder for destination: %w", err)
 		}
 	}
 
 	out, err := os.Create(destination)
 	if err != nil {
-		return fmt.Errorf("creating %s: %v", destination, err)
+		return fmt.Errorf("creating %s: %w", destination, err)
 	}
 	defer out.Close()
 
 	err = t.Create(out)
 	if err != nil {
-		return fmt.Errorf("creating tar: %v", err)
+		return fmt.Errorf("creating tar: %w", err)
 	}
 	defer t.Close()
 
@@ -119,7 +119,7 @@ func (t *Tar) Archive(sources []string, destination string) error {
 	for _, source := range sources {
 		err := t.writeWalk(source, topLevelFolder, destination)
 		if err != nil {
-			return fmt.Errorf("walking %s: %v", source, err)
+			return fmt.Errorf("walking %s: %w", source, err)
 		}
 	}
 
@@ -132,7 +132,7 @@ func (t *Tar) Unarchive(source, destination string) error {
 	if !fileExists(destination) && t.MkdirAll {
 		err := mkdir(destination, 0755)
 		if err != nil {
-			return fmt.Errorf("preparing destination: %v", err)
+			return fmt.Errorf("preparing destination: %w", err)
 		}
 	}
 
@@ -143,19 +143,19 @@ func (t *Tar) Unarchive(source, destination string) error {
 		var err error
 		destination, err = t.addTopLevelFolder(source, destination)
 		if err != nil {
-			return fmt.Errorf("scanning source archive: %v", err)
+			return fmt.Errorf("scanning source archive: %w", err)
 		}
 	}
 
 	file, err := os.Open(source)
 	if err != nil {
-		return fmt.Errorf("opening source archive: %v", err)
+		return fmt.Errorf("opening source archive: %w", err)
 	}
 	defer file.Close()
 
 	err = t.Open(file, 0)
 	if err != nil {
-		return fmt.Errorf("opening tar archive for reading: %v", err)
+		return fmt.Errorf("opening tar archive for reading: %w", err)
 	}
 	defer t.Close()
 
@@ -169,7 +169,7 @@ func (t *Tar) Unarchive(source, destination string) error {
 				log.Printf("[ERROR] Reading file in tar archive: %v", err)
 				continue
 			}
-			return fmt.Errorf("reading file in tar archive: %v", err)
+			return fmt.Errorf("reading file in tar archive: %w", err)
 		}
 	}
 
@@ -183,7 +183,7 @@ func (t *Tar) Unarchive(source, destination string) error {
 func (t *Tar) addTopLevelFolder(sourceArchive, destination string) (string, error) {
 	file, err := os.Open(sourceArchive)
 	if err != nil {
-		return "", fmt.Errorf("opening source archive: %v", err)
+		return "", fmt.Errorf("opening source archive: %w", err)
 	}
 	defer file.Close()
 
@@ -193,7 +193,7 @@ func (t *Tar) addTopLevelFolder(sourceArchive, destination string) (string, erro
 	if t.readerWrapFn != nil {
 		reader, err = t.readerWrapFn(reader)
 		if err != nil {
-			return "", fmt.Errorf("wrapping reader: %v", err)
+			return "", fmt.Errorf("wrapping reader: %w", err)
 		}
 	}
 	if t.cleanupWrapFn != nil {
@@ -209,7 +209,7 @@ func (t *Tar) addTopLevelFolder(sourceArchive, destination string) (string, erro
 			break
 		}
 		if err != nil {
-			return "", fmt.Errorf("scanning tarball's file listing: %v", err)
+			return "", fmt.Errorf("scanning tarball's file listing: %w", err)
 		}
 		files = append(files, hdr.Name)
 	}
@@ -278,11 +278,11 @@ func (t *Tar) untarFile(f File, destination string, hdr *tar.Header) error {
 func (t *Tar) writeWalk(source, topLevelFolder, destination string) error {
 	sourceInfo, err := os.Stat(source)
 	if err != nil {
-		return fmt.Errorf("%s: stat: %v", source, err)
+		return fmt.Errorf("%s: stat: %w", source, err)
 	}
 	destAbs, err := filepath.Abs(destination)
 	if err != nil {
-		return fmt.Errorf("%s: getting absolute path of destination %s: %v", source, destination, err)
+		return fmt.Errorf("%s: getting absolute path of destination %s: %w", source, destination, err)
 	}
 
 	return filepath.Walk(source, func(fpath string, info os.FileInfo, err error) error {
@@ -294,7 +294,7 @@ func (t *Tar) writeWalk(source, topLevelFolder, destination string) error {
 			return err
 		}
 		if err != nil {
-			return handleErr(fmt.Errorf("traversing %s: %v", fpath, err))
+			return handleErr(fmt.Errorf("traversing %s: %w", fpath, err))
 		}
 		if info == nil {
 			return handleErr(fmt.Errorf("no file info"))
@@ -303,7 +303,7 @@ func (t *Tar) writeWalk(source, topLevelFolder, destination string) error {
 		// make sure we do not copy our output file into itself
 		fpathAbs, err := filepath.Abs(fpath)
 		if err != nil {
-			return handleErr(fmt.Errorf("%s: getting absolute path: %v", fpath, err))
+			return handleErr(fmt.Errorf("%s: getting absolute path: %w", fpath, err))
 		}
 		if within(fpathAbs, destAbs) {
 			return nil
@@ -319,7 +319,7 @@ func (t *Tar) writeWalk(source, topLevelFolder, destination string) error {
 		if info.Mode().IsRegular() {
 			file, err = os.Open(fpath)
 			if err != nil {
-				return handleErr(fmt.Errorf("%s: opening: %v", fpath, err))
+				return handleErr(fmt.Errorf("%s: opening: %w", fpath, err))
 			}
 			defer file.Close()
 		}
@@ -350,7 +350,7 @@ func (t *Tar) Create(out io.Writer) error {
 		var err error
 		out, err = t.writerWrapFn(out)
 		if err != nil {
-			return fmt.Errorf("wrapping writer: %v", err)
+			return fmt.Errorf("wrapping writer: %w", err)
 		}
 	}
 
@@ -375,18 +375,18 @@ func (t *Tar) Write(f File) error {
 		var err error
 		linkTarget, err = os.Readlink(f.Name())
 		if err != nil {
-			return fmt.Errorf("%s: readlink: %v", f.Name(), err)
+			return fmt.Errorf("%s: readlink: %w", f.Name(), err)
 		}
 	}
 
 	hdr, err := tar.FileInfoHeader(f, filepath.ToSlash(linkTarget))
 	if err != nil {
-		return fmt.Errorf("%s: making header: %v", f.Name(), err)
+		return fmt.Errorf("%s: making header: %w", f.Name(), err)
 	}
 
 	err = t.tw.WriteHeader(hdr)
 	if err != nil {
-		return fmt.Errorf("%s: writing header: %v", hdr.Name, err)
+		return fmt.Errorf("%s: writing header: %w", hdr.Name, err)
 	}
 
 	if f.IsDir() {
@@ -399,7 +399,7 @@ func (t *Tar) Write(f File) error {
 		}
 		_, err := io.Copy(t.tw, f)
 		if err != nil {
-			return fmt.Errorf("%s: copying contents: %v", f.Name(), err)
+			return fmt.Errorf("%s: copying contents: %w", f.Name(), err)
 		}
 	}
 
@@ -417,7 +417,7 @@ func (t *Tar) Open(in io.Reader, size int64) error {
 		var err error
 		in, err = t.readerWrapFn(in)
 		if err != nil {
-			return fmt.Errorf("wrapping file reader: %v", err)
+			return fmt.Errorf("wrapping file reader: %w", err)
 		}
 	}
 	t.tr = tar.NewReader(in)
@@ -471,13 +471,13 @@ func (t *Tar) Close() error {
 func (t *Tar) Walk(archive string, walkFn WalkFunc) error {
 	file, err := os.Open(archive)
 	if err != nil {
-		return fmt.Errorf("opening archive file: %v", err)
+		return fmt.Errorf("opening archive file: %w", err)
 	}
 	defer file.Close()
 
 	err = t.Open(file, 0)
 	if err != nil {
-		return fmt.Errorf("opening archive: %v", err)
+		return fmt.Errorf("opening archive: %w", err)
 	}
 	defer t.Close()
 
@@ -491,7 +491,7 @@ func (t *Tar) Walk(archive string, walkFn WalkFunc) error {
 				log.Printf("[ERROR] Opening next file: %v", err)
 				continue
 			}
-			return fmt.Errorf("opening next file: %v", err)
+			return fmt.Errorf("opening next file: %w", err)
 		}
 		err = walkFn(f)
 		if err != nil {
@@ -502,7 +502,7 @@ func (t *Tar) Walk(archive string, walkFn WalkFunc) error {
 				log.Printf("[ERROR] Walking %s: %v", f.Name(), err)
 				continue
 			}
-			return fmt.Errorf("walking %s: %v", f.Name(), err)
+			return fmt.Errorf("walking %s: %w", f.Name(), err)
 		}
 	}
 
@@ -541,7 +541,7 @@ func (t *Tar) Extract(source, target, destination string) error {
 			// build the filename we will extract to
 			end, err := filepath.Rel(targetDirPath, th.Name)
 			if err != nil {
-				return fmt.Errorf("relativizing paths: %v", err)
+				return fmt.Errorf("relativizing paths: %w", err)
 			}
 			th.Name = end
 
@@ -552,7 +552,7 @@ func (t *Tar) Extract(source, target, destination string) error {
 
 			err = t.untarFile(f, destination, th)
 			if err != nil {
-				return fmt.Errorf("extracting file %s: %v", th.Name, err)
+				return fmt.Errorf("extracting file %s: %w", th.Name, err)
 			}
 
 			// if our target was not a directory, stop walk
diff --git a/zip.go b/zip.go
index 8a552017..0d400093 100644
--- a/zip.go
+++ b/zip.go
@@ -140,7 +140,7 @@ func (*Zip) CheckPath(to, filename string) error {
 func (z *Zip) Archive(sources []string, destination string) error {
 	err := z.CheckExt(destination)
 	if err != nil {
-		return fmt.Errorf("checking extension: %v", err)
+		return fmt.Errorf("checking extension: %w", err)
 	}
 	if !z.OverwriteExisting && fileExists(destination) {
 		return fmt.Errorf("file already exists: %s", destination)
@@ -152,19 +152,19 @@ func (z *Zip) Archive(sources []string, destination string) error {
 	if z.MkdirAll && !fileExists(destDir) {
 		err := mkdir(destDir, 0755)
 		if err != nil {
-			return fmt.Errorf("making folder for destination: %v", err)
+			return fmt.Errorf("making folder for destination: %w", err)
 		}
 	}
 
 	out, err := os.Create(destination)
 	if err != nil {
-		return fmt.Errorf("creating %s: %v", destination, err)
+		return fmt.Errorf("creating %s: %w", destination, err)
 	}
 	defer out.Close()
 
 	err = z.Create(out)
 	if err != nil {
-		return fmt.Errorf("creating zip: %v", err)
+		return fmt.Errorf("creating zip: %w", err)
 	}
 	defer z.Close()
 
@@ -176,7 +176,7 @@ func (z *Zip) Archive(sources []string, destination string) error {
 	for _, source := range sources {
 		err := z.writeWalk(source, topLevelFolder, destination)
 		if err != nil {
-			return fmt.Errorf("walking %s: %v", source, err)
+			return fmt.Errorf("walking %s: %w", source, err)
 		}
 	}
 
@@ -189,24 +189,24 @@ func (z *Zip) Unarchive(source, destination string) error {
 	if !fileExists(destination) && z.MkdirAll {
 		err := mkdir(destination, 0755)
 		if err != nil {
-			return fmt.Errorf("preparing destination: %v", err)
+			return fmt.Errorf("preparing destination: %w", err)
 		}
 	}
 
 	file, err := os.Open(source)
 	if err != nil {
-		return fmt.Errorf("opening source file: %v", err)
+		return fmt.Errorf("opening source file: %w", err)
 	}
 	defer file.Close()
 
 	fileInfo, err := file.Stat()
 	if err != nil {
-		return fmt.Errorf("statting source file: %v", err)
+		return fmt.Errorf("statting source file: %w", err)
 	}
 
 	err = z.Open(file, fileInfo.Size())
 	if err != nil {
-		return fmt.Errorf("opening zip archive for reading: %v", err)
+		return fmt.Errorf("opening zip archive for reading: %w", err)
 	}
 	defer z.Close()
 
@@ -233,7 +233,7 @@ func (z *Zip) Unarchive(source, destination string) error {
 				log.Printf("[ERROR] Reading file in zip archive: %v", err)
 				continue
 			}
-			return fmt.Errorf("reading file in zip archive: %v", err)
+			return fmt.Errorf("reading file in zip archive: %w", err)
 		}
 	}
 
@@ -289,7 +289,7 @@ func (z *Zip) extractFile(f File, to string, header *zip.FileHeader) error {
 		buf := new(bytes.Buffer)
 		_, err := io.Copy(buf, f)
 		if err != nil {
-			return fmt.Errorf("%s: reading symlink target: %v", header.Name, err)
+			return fmt.Errorf("%s: reading symlink target: %w", header.Name, err)
 		}
 		return writeNewSymbolicLink(to, strings.TrimSpace(buf.String()))
 	}
@@ -300,11 +300,11 @@ func (z *Zip) extractFile(f File, to string, header *zip.FileHeader) error {
 func (z *Zip) writeWalk(source, topLevelFolder, destination string) error {
 	sourceInfo, err := os.Stat(source)
 	if err != nil {
-		return fmt.Errorf("%s: stat: %v", source, err)
+		return fmt.Errorf("%s: stat: %w", source, err)
 	}
 	destAbs, err := filepath.Abs(destination)
 	if err != nil {
-		return fmt.Errorf("%s: getting absolute path of destination %s: %v", source, destination, err)
+		return fmt.Errorf("%s: getting absolute path of destination %s: %w", source, destination, err)
 	}
 
 	return filepath.Walk(source, func(fpath string, info os.FileInfo, err error) error {
@@ -316,7 +316,7 @@ func (z *Zip) writeWalk(source, topLevelFolder, destination string) error {
 			return err
 		}
 		if err != nil {
-			return handleErr(fmt.Errorf("traversing %s: %v", fpath, err))
+			return handleErr(fmt.Errorf("traversing %s: %w", fpath, err))
 		}
 		if info == nil {
 			return handleErr(fmt.Errorf("%s: no file info", fpath))
@@ -326,7 +326,7 @@ func (z *Zip) writeWalk(source, topLevelFolder, destination string) error {
 		// file; that results in an infinite loop and disk exhaustion!
 		fpathAbs, err := filepath.Abs(fpath)
 		if err != nil {
-			return handleErr(fmt.Errorf("%s: getting absolute path: %v", fpath, err))
+			return handleErr(fmt.Errorf("%s: getting absolute path: %w", fpath, err))
 		}
 		if within(fpathAbs, destAbs) {
 			return nil
@@ -342,7 +342,7 @@ func (z *Zip) writeWalk(source, topLevelFolder, destination string) error {
 		if info.Mode().IsRegular() {
 			file, err = os.Open(fpath)
 			if err != nil {
-				return handleErr(fmt.Errorf("%s: opening: %v", fpath, err))
+				return handleErr(fmt.Errorf("%s: opening: %w", fpath, err))
 			}
 			defer file.Close()
 		}
@@ -403,7 +403,7 @@ func (z *Zip) Write(f File) error {
 
 	header, err := zip.FileInfoHeader(f)
 	if err != nil {
-		return fmt.Errorf("%s: getting header: %v", f.Name(), err)
+		return fmt.Errorf("%s: getting header: %w", f.Name(), err)
 	}
 
 	if f.IsDir() {
@@ -420,7 +420,7 @@ func (z *Zip) Write(f File) error {
 
 	writer, err := z.zw.CreateHeader(header)
 	if err != nil {
-		return fmt.Errorf("%s: making header: %v", f.Name(), err)
+		return fmt.Errorf("%s: making header: %w", f.Name(), err)
 	}
 
 	return z.writeFile(f, writer)
@@ -434,11 +434,11 @@ func (z *Zip) writeFile(f File, writer io.Writer) error {
 		// file body for symlinks is the symlink target
 		linkTarget, err := os.Readlink(f.Name())
 		if err != nil {
-			return fmt.Errorf("%s: readlink: %v", f.Name(), err)
+			return fmt.Errorf("%s: readlink: %w", f.Name(), err)
 		}
 		_, err = writer.Write([]byte(filepath.ToSlash(linkTarget)))
 		if err != nil {
-			return fmt.Errorf("%s: writing symlink target: %v", f.Name(), err)
+			return fmt.Errorf("%s: writing symlink target: %w", f.Name(), err)
 		}
 		return nil
 	}
@@ -448,7 +448,7 @@ func (z *Zip) writeFile(f File, writer io.Writer) error {
 	}
 	_, err := io.Copy(writer, f)
 	if err != nil {
-		return fmt.Errorf("%s: copying contents: %v", f.Name(), err)
+		return fmt.Errorf("%s: copying contents: %w", f.Name(), err)
 	}
 
 	return nil
@@ -468,7 +468,7 @@ func (z *Zip) Open(in io.Reader, size int64) error {
 	var err error
 	z.zr, err = zip.NewReader(inRdrAt, size)
 	if err != nil {
-		return fmt.Errorf("creating reader: %v", err)
+		return fmt.Errorf("creating reader: %w", err)
 	}
 	registerDecompressor(z.zr)
 	z.ridx = 0
@@ -500,7 +500,7 @@ func (z *Zip) Read() (File, error) {
 
 	rc, err := zf.Open()
 	if err != nil {
-		return file, fmt.Errorf("%s: open compressed file: %v", zf.Name, err)
+		return file, fmt.Errorf("%s: open compressed file: %w", zf.Name, err)
 	}
 	file.ReadCloser = rc
 
@@ -524,7 +524,7 @@ func (z *Zip) Close() error {
 func (z *Zip) Walk(archive string, walkFn WalkFunc) error {
 	zr, err := zip.OpenReader(archive)
 	if err != nil {
-		return fmt.Errorf("opening zip reader: %v", err)
+		return fmt.Errorf("opening zip reader: %w", err)
 	}
 	defer zr.Close()
 	registerDecompressor(&zr.Reader)
@@ -538,7 +538,7 @@ func (z *Zip) Walk(archive string, walkFn WalkFunc) error {
 				log.Printf("[ERROR] Opening %s: %v", zf.Name, err)
 				continue
 			}
-			return fmt.Errorf("opening %s: %v", zf.Name, err)
+			return fmt.Errorf("opening %s: %w", zf.Name, err)
 		}
 
 		err = walkFn(File{
@@ -555,7 +555,7 @@ func (z *Zip) Walk(archive string, walkFn WalkFunc) error {
 				log.Printf("[ERROR] Walking %s: %v", zf.Name, err)
 				continue
 			}
-			return fmt.Errorf("walking %s: %v", zf.Name, err)
+			return fmt.Errorf("walking %s: %w", zf.Name, err)
 		}
 	}
 
@@ -594,13 +594,13 @@ func (z *Zip) Extract(source, target, destination string) error {
 			// build the filename we will extract to
 			end, err := filepath.Rel(targetDirPath, zfh.Name)
 			if err != nil {
-				return fmt.Errorf("relativizing paths: %v", err)
+				return fmt.Errorf("relativizing paths: %w", err)
 			}
 			joined := filepath.Join(destination, end)
 
 			err = z.extractFile(f, joined, &zfh)
 			if err != nil {
-				return fmt.Errorf("extracting file %s: %v", zfh.Name, err)
+				return fmt.Errorf("extracting file %s: %w", zfh.Name, err)
 			}
 
 			// if our target was not a directory, stop walk