vendor: go mod vendor

We don't want to download mockery every time.

1 files changed, 657 insertions, 0 deletions

diff --git a/vendor/github.com/chigopher/pathlib/path.go b/vendor/github.com/chigopher/pathlib/path.go
new file mode 100644
index 000000000..2f802e159
--- /dev/null
+++ b/vendor/github.com/chigopher/pathlib/path.go
@@ -0,0 +1,657 @@
+package pathlib
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/spf13/afero"
+)
+
+// Path is an object that represents a path
+type Path struct {
+	path string
+	fs   afero.Fs
+
+	// DefaultFileMode is the mode that is used when creating new files in functions
+	// that do not accept os.FileMode as a parameter.
+	DefaultFileMode os.FileMode
+	// DefaultDirMode is the mode that will be used when creating new directories
+	DefaultDirMode os.FileMode
+	// Sep is the seperator used in path calculations. By default this is set to
+	// os.PathSeparator.
+	Sep string
+}
+
+type PathOpts func(p *Path)
+
+func PathWithAfero(fs afero.Fs) PathOpts {
+	return func(p *Path) {
+		p.fs = fs
+	}
+}
+
+func PathWithSeperator(sep string) PathOpts {
+	return func(p *Path) {
+		p.Sep = sep
+	}
+}
+
+// NewPath returns a new OS path
+func NewPath(path string, opts ...PathOpts) *Path {
+	p := &Path{
+		path:            path,
+		fs:              afero.NewOsFs(),
+		DefaultFileMode: DefaultFileMode,
+		DefaultDirMode:  DefaultDirMode,
+		Sep:             string(os.PathSeparator),
+	}
+	for _, opt := range opts {
+		opt(p)
+	}
+	return p
+}
+
+// NewPathAfero returns a Path object with the given Afero object
+//
+// Deprecated: Use the PathWithAfero option in Newpath instead.
+func NewPathAfero(path string, fs afero.Fs) *Path {
+	return NewPath(path, PathWithAfero(fs))
+}
+
+// Glob returns all of the path objects matched by the given pattern
+// inside of the afero filesystem.
+func Glob(fs afero.Fs, pattern string) ([]*Path, error) {
+	matches, err := afero.Glob(fs, pattern)
+	if err != nil {
+		return nil, fmt.Errorf("failed to glob: %w", err)
+	}
+
+	pathMatches := []*Path{}
+	for _, match := range matches {
+		pathMatches = append(pathMatches, NewPathAfero(match, fs))
+	}
+	return pathMatches, nil
+}
+
+type namer interface {
+	Name() string
+}
+
+func getFsName(fs afero.Fs) string {
+	if name, ok := fs.(namer); ok {
+		return name.Name()
+	}
+	return ""
+}
+
+// Fs returns the internal afero.Fs object.
+func (p *Path) Fs() afero.Fs {
+	return p.fs
+}
+
+func (p *Path) doesNotImplementErr(interfaceName string) error {
+	return doesNotImplementErr(interfaceName, p.Fs())
+}
+
+func doesNotImplementErr(interfaceName string, fs afero.Fs) error {
+	return fmt.Errorf("%w: Path's afero filesystem %s does not implement %s", ErrDoesNotImplement, getFsName(fs), interfaceName)
+}
+
+func (p *Path) lstatNotPossible() error {
+	return lstatNotPossible(p.Fs())
+}
+
+func lstatNotPossible(fs afero.Fs) error {
+	return fmt.Errorf("%w: Path's afero filesystem %s does not support lstat", ErrLstatNotPossible, getFsName(fs))
+}
+
+// *******************************
+// * afero.Fs wrappers           *
+// *******************************
+
+// Create creates a file if possible, returning the file and an error, if any happens.
+func (p *Path) Create() (File, error) {
+	file, err := p.Fs().Create(p.String())
+	return File{file}, err
+}
+
+// Mkdir makes the current dir. If the parents don't exist, an error
+// is returned.
+func (p *Path) Mkdir() error {
+	return p.Fs().Mkdir(p.String(), p.DefaultDirMode)
+}
+
+// MkdirMode makes the current dir. If the parents don't exist, an error
+// is returned.
+func (p *Path) MkdirMode(perm os.FileMode) error {
+	return p.Fs().Mkdir(p.String(), perm)
+}
+
+// MkdirAll makes all of the directories up to, and including, the given path.
+func (p *Path) MkdirAll() error {
+	return p.Fs().MkdirAll(p.String(), p.DefaultDirMode)
+}
+
+// MkdirAllMode makes all of the directories up to, and including, the given path.
+func (p *Path) MkdirAllMode(perm os.FileMode) error {
+	return p.Fs().MkdirAll(p.String(), perm)
+}
+
+// Open opens a file for read-only, returning it or an error, if any happens.
+func (p *Path) Open() (*File, error) {
+	handle, err := p.Fs().Open(p.String())
+	return &File{
+		File: handle,
+	}, err
+}
+
+// OpenFile opens a file using the given flags.
+// See the list of flags at: https://golang.org/pkg/os/#pkg-constants
+func (p *Path) OpenFile(flag int) (*File, error) {
+	handle, err := p.Fs().OpenFile(p.String(), flag, p.DefaultFileMode)
+	return &File{
+		File: handle,
+	}, err
+}
+
+// OpenFileMode opens a file using the given flags and the given mode.
+// See the list of flags at: https://golang.org/pkg/os/#pkg-constants
+func (p *Path) OpenFileMode(flag int, perm os.FileMode) (*File, error) {
+	handle, err := p.Fs().OpenFile(p.String(), flag, perm)
+	return &File{
+		File: handle,
+	}, err
+}
+
+// Remove removes a file, returning an error, if any
+// happens.
+func (p *Path) Remove() error {
+	return p.Fs().Remove(p.String())
+}
+
+// RemoveAll removes the given path and all of its children.
+func (p *Path) RemoveAll() error {
+	return p.Fs().RemoveAll(p.String())
+}
+
+// RenameStr renames a file
+func (p *Path) RenameStr(newname string) error {
+	if err := p.Fs().Rename(p.String(), newname); err != nil {
+		return err
+	}
+
+	// Rename succeeded. Set our path to the newname.
+	p.path = newname
+	return nil
+}
+
+// Rename renames a file
+func (p *Path) Rename(target *Path) error {
+	return p.RenameStr(target.String())
+}
+
+// Stat returns the os.FileInfo of the given path
+func (p *Path) Stat() (os.FileInfo, error) {
+	return p.Fs().Stat(p.String())
+}
+
+// Chmod changes the file mode of the given path
+func (p *Path) Chmod(mode os.FileMode) error {
+	return p.Fs().Chmod(p.String(), mode)
+}
+
+// Chtimes changes the modification and access time of the given path.
+func (p *Path) Chtimes(atime time.Time, mtime time.Time) error {
+	return p.Fs().Chtimes(p.String(), atime, mtime)
+}
+
+// ************************
+// * afero.Afero wrappers *
+// ************************
+
+// DirExists returns whether or not the path represents a directory that exists
+func (p *Path) DirExists() (bool, error) {
+	return afero.DirExists(p.Fs(), p.String())
+}
+
+// Exists returns whether the path exists
+func (p *Path) Exists() (bool, error) {
+	return afero.Exists(p.Fs(), p.String())
+}
+
+// FileContainsAnyBytes returns whether or not the path contains
+// any of the listed bytes.
+func (p *Path) FileContainsAnyBytes(subslices [][]byte) (bool, error) {
+	return afero.FileContainsAnyBytes(p.Fs(), p.String(), subslices)
+}
+
+// FileContainsBytes returns whether or not the given file contains the bytes
+func (p *Path) FileContainsBytes(subslice []byte) (bool, error) {
+	return afero.FileContainsBytes(p.Fs(), p.String(), subslice)
+}
+
+// IsDir checks if a given path is a directory.
+func (p *Path) IsDir() (bool, error) {
+	return afero.IsDir(p.Fs(), p.String())
+}
+
+// IsDir returns whether or not the os.FileMode object represents a
+// directory.
+func IsDir(mode os.FileMode) bool {
+	return mode.IsDir()
+}
+
+// IsEmpty checks if a given file or directory is empty.
+func (p *Path) IsEmpty() (bool, error) {
+	return afero.IsEmpty(p.Fs(), p.String())
+}
+
+// ReadDir reads the current path and returns a list of the corresponding
+// Path objects. This function differs from os.Readdir in that it does
+// not call Stat() on the files. Instead, it calls Readdirnames which
+// is less expensive and does not force the caller to make expensive
+// Stat calls.
+func (p *Path) ReadDir() ([]*Path, error) {
+	paths := []*Path{}
+	handle, err := p.Open()
+	if err != nil {
+		return paths, err
+	}
+	children, err := handle.Readdirnames(-1)
+	if err != nil {
+		return paths, err
+	}
+	for _, child := range children {
+		paths = append(paths, p.Join(child))
+	}
+	return paths, err
+}
+
+// ReadFile reads the given path and returns the data. If the file doesn't exist
+// or is a directory, an error is returned.
+func (p *Path) ReadFile() ([]byte, error) {
+	return afero.ReadFile(p.Fs(), p.String())
+}
+
+// SafeWriteReader is the same as WriteReader but checks to see if file/directory already exists.
+func (p *Path) SafeWriteReader(r io.Reader) error {
+	return afero.SafeWriteReader(p.Fs(), p.String(), r)
+}
+
+// WriteFileMode writes the given data to the path (if possible). If the file exists,
+// the file is truncated. If the file is a directory, or the path doesn't exist,
+// an error is returned.
+func (p *Path) WriteFileMode(data []byte, perm os.FileMode) error {
+	return afero.WriteFile(p.Fs(), p.String(), data, perm)
+}
+
+// WriteFile writes the given data to the path (if possible). If the file exists,
+// the file is truncated. If the file is a directory, or the path doesn't exist,
+// an error is returned.
+func (p *Path) WriteFile(data []byte) error {
+	return afero.WriteFile(p.Fs(), p.String(), data, p.DefaultFileMode)
+}
+
+// WriteReader takes a reader and writes the content
+func (p *Path) WriteReader(r io.Reader) error {
+	return afero.WriteReader(p.Fs(), p.String(), r)
+}
+
+// *************************************
+// * pathlib.Path-like implementations *
+// *************************************
+
+// Name returns the string representing the final path component
+func (p *Path) Name() string {
+	return filepath.Base(p.path)
+}
+
+// Parent returns the Path object of the parent directory
+func (p *Path) Parent() *Path {
+	return NewPathAfero(filepath.Dir(p.String()), p.Fs())
+}
+
+// Readlink returns the target path of a symlink.
+//
+// This will fail if the underlying afero filesystem does not implement
+// afero.LinkReader.
+func (p *Path) Readlink() (*Path, error) {
+	linkReader, ok := p.Fs().(afero.LinkReader)
+	if !ok {
+		return nil, p.doesNotImplementErr("afero.LinkReader")
+	}
+
+	resolvedPathStr, err := linkReader.ReadlinkIfPossible(p.path)
+	if err != nil {
+		return nil, err
+	}
+	return NewPathAfero(resolvedPathStr, p.fs), nil
+}
+
+func resolveIfSymlink(path *Path) (*Path, bool, error) {
+	isSymlink, err := path.IsSymlink()
+	if err != nil {
+		return path, isSymlink, err
+	}
+	if isSymlink {
+		resolvedPath, err := path.Readlink()
+		if err != nil {
+			// Return the path unchanged on errors
+			return path, isSymlink, err
+		}
+		return resolvedPath, isSymlink, nil
+	}
+	return path, isSymlink, nil
+}
+
+func resolveAllHelper(path *Path) (*Path, error) {
+	parts := path.Parts()
+
+	for i := 0; i < len(parts); i++ {
+		rightOfComponent := parts[i+1:]
+		upToComponent := parts[:i+1]
+
+		componentPath := NewPathAfero(strings.Join(upToComponent, path.Sep), path.Fs())
+		resolved, isSymlink, err := resolveIfSymlink(componentPath)
+		if err != nil {
+			return path, err
+		}
+
+		if isSymlink {
+			if resolved.IsAbsolute() {
+				return resolveAllHelper(resolved.Join(strings.Join(rightOfComponent, path.Sep)))
+			}
+			return resolveAllHelper(componentPath.Parent().JoinPath(resolved).Join(rightOfComponent...))
+		}
+	}
+
+	// If we get through the entire iteration above, that means no component was a symlink.
+	// Return the argument.
+	return path, nil
+}
+
+// ResolveAll canonicalizes the path by following every symlink in
+// every component of the given path recursively. The behavior
+// should be identical to the `readlink -f` command from POSIX OSs.
+// This will fail if the underlying afero filesystem does not implement
+// afero.LinkReader. The path will be returned unchanged on errors.
+func (p *Path) ResolveAll() (*Path, error) {
+	return resolveAllHelper(p)
+}
+
+// Parts returns the individual components of a path
+func (p *Path) Parts() []string {
+	parts := []string{}
+	if p.IsAbsolute() {
+		parts = append(parts, p.Sep)
+	}
+	normalizedPathStr := normalizePathString(p.String())
+	normalizedParts := normalizePathParts(strings.Split(normalizedPathStr, p.Sep))
+	return append(parts, normalizedParts...)
+}
+
+// IsAbsolute returns whether or not the path is an absolute path. This is
+// determined by checking if the path starts with a slash.
+func (p *Path) IsAbsolute() bool {
+	return strings.HasPrefix(p.path, "/")
+}
+
+// Join joins the current object's path with the given elements and returns
+// the resulting Path object.
+func (p *Path) Join(elems ...string) *Path {
+	paths := []string{p.path}
+	paths = append(paths, elems...)
+	return NewPathAfero(strings.Join(paths, p.Sep), p.Fs())
+}
+
+// JoinPath is the same as Join() except it accepts a path object
+func (p *Path) JoinPath(path *Path) *Path {
+	return p.Join(path.Parts()...)
+}
+
+func normalizePathString(path string) string {
+	path = strings.TrimSpace(path)
+	path = strings.TrimPrefix(path, "./")
+	path = strings.TrimRight(path, " ")
+	if len(path) > 1 {
+		path = strings.TrimSuffix(path, "/")
+	}
+	return path
+}
+
+func normalizePathParts(path []string) []string {
+	// We might encounter cases where path represents a split of the path
+	// "///" etc. We will get a bunch of erroneous empty strings in such a split,
+	// so remove all of the trailing empty strings except for the first one (if any)
+	normalized := []string{}
+	for i := 0; i < len(path); i++ {
+		if path[i] != "" {
+			normalized = append(normalized, path[i])
+		}
+	}
+	return normalized
+}
+
+// RelativeTo computes a relative version of path to the other path. For instance,
+// if the object is /path/to/foo.txt and you provide /path/ as the argment, the
+// returned Path object will represent to/foo.txt.
+func (p *Path) RelativeTo(other *Path) (*Path, error) {
+	thisPathNormalized := normalizePathString(p.String())
+	otherPathNormalized := normalizePathString(other.String())
+
+	thisParts := p.Parts()
+	otherParts := other.Parts()
+
+	var relativeBase int
+	for idx, part := range otherParts {
+		if idx >= len(thisParts) || thisParts[idx] != part {
+			return p, fmt.Errorf("%s does not start with %s: %w", thisPathNormalized, otherPathNormalized, ErrRelativeTo)
+		}
+		relativeBase = idx
+	}
+
+	relativePath := thisParts[relativeBase+1:]
+
+	if len(relativePath) == 0 || (len(relativePath) == 1 && relativePath[0] == "") {
+		relativePath = []string{"."}
+	}
+
+	return NewPathAfero(strings.Join(relativePath, "/"), p.Fs()), nil
+}
+
+// RelativeToStr computes a relative version of path to the other path. For instance,
+// if the object is /path/to/foo.txt and you provide /path/ as the argment, the
+// returned Path object will represent to/foo.txt.
+func (p *Path) RelativeToStr(other string) (*Path, error) {
+	return p.RelativeTo(NewPathAfero(other, p.Fs()))
+}
+
+// Lstat lstat's the path if the underlying afero filesystem supports it. If
+// the filesystem does not support afero.Lstater, or if the filesystem implements
+// afero.Lstater but returns false for the "lstat called" return value.
+//
+// A nil os.FileInfo is returned on errors.
+func (p *Path) Lstat() (os.FileInfo, error) {
+	lStater, ok := p.Fs().(afero.Lstater)
+	if !ok {
+		return nil, p.doesNotImplementErr("afero.Lstater")
+	}
+	stat, lstatCalled, err := lStater.LstatIfPossible(p.String())
+	if !lstatCalled && err == nil {
+		return nil, p.lstatNotPossible()
+	}
+	return stat, err
+}
+
+// SymlinkStr symlinks to the target location. This will fail if the underlying
+// afero filesystem does not implement afero.Linker.
+func (p *Path) SymlinkStr(target string) error {
+	return p.Symlink(NewPathAfero(target, p.Fs()))
+}
+
+// Symlink symlinks to the target location. This will fail if the underlying
+// afero filesystem does not implement afero.Linker.
+func (p *Path) Symlink(target *Path) error {
+	symlinker, ok := p.fs.(afero.Linker)
+	if !ok {
+		return p.doesNotImplementErr("afero.Linker")
+	}
+
+	return symlinker.SymlinkIfPossible(target.path, p.path)
+}
+
+// String returns the string representation of the path
+func (p *Path) String() string {
+	return p.path
+}
+
+// IsFile returns true if the given path is a file.
+func (p *Path) IsFile() (bool, error) {
+	fileInfo, err := p.Stat()
+	if err != nil {
+		return false, err
+	}
+	return IsFile(fileInfo.Mode()), nil
+}
+
+// IsFile returns whether or not the file described by the given
+// os.FileMode is a regular file.
+func IsFile(mode os.FileMode) bool {
+	return mode.IsRegular()
+}
+
+// IsSymlink returns true if the given path is a symlink.
+// Fails if the filesystem doesn't implement afero.Lstater.
+func (p *Path) IsSymlink() (bool, error) {
+	fileInfo, err := p.Lstat()
+	if err != nil {
+		return false, err
+	}
+	return IsSymlink(fileInfo.Mode()), nil
+}
+
+// IsSymlink returns true if the file described by the given
+// os.FileMode describes a symlink.
+func IsSymlink(mode os.FileMode) bool {
+	return mode&os.ModeSymlink != 0
+}
+
+// DeepEquals returns whether or not the path pointed to by other
+// has the same resolved filepath as self.
+func (p *Path) DeepEquals(other *Path) (bool, error) {
+	selfResolved, err := p.ResolveAll()
+	if err != nil {
+		return false, err
+	}
+	otherResolved, err := other.ResolveAll()
+	if err != nil {
+		return false, err
+	}
+
+	return selfResolved.Clean().Equals(otherResolved.Clean()), nil
+}
+
+// Equals returns whether or not the object's path is identical
+// to other's, in a shallow sense. It simply checks for equivalence
+// in the unresolved Paths() of each object.
+func (p *Path) Equals(other *Path) bool {
+	return p.String() == other.String()
+}
+
+// GetLatest returns the file or directory that has the most recent mtime. Only
+// works if this path is a directory and it exists. If the directory is empty,
+// the returned Path object will be nil.
+func (p *Path) GetLatest() (*Path, error) {
+	files, err := p.ReadDir()
+	if err != nil {
+		return nil, err
+	}
+
+	var greatestFileSeen *Path
+	for _, file := range files {
+		if greatestFileSeen == nil {
+			greatestFileSeen = p.Join(file.Name())
+		}
+
+		greatestMtime, err := greatestFileSeen.Mtime()
+		if err != nil {
+			return nil, err
+		}
+
+		thisMtime, err := file.Mtime()
+		// There is a possible race condition where the file is deleted after
+		// our call to ReadDir. We throw away the error if it isn't
+		// os.ErrNotExist
+		if err != nil && !os.IsNotExist(err) {
+			return nil, err
+		}
+		if thisMtime.After(greatestMtime) {
+			greatestFileSeen = p.Join(file.Name())
+		}
+	}
+
+	return greatestFileSeen, nil
+}
+
+// Glob returns all matches of pattern relative to this object's path.
+func (p *Path) Glob(pattern string) ([]*Path, error) {
+	return Glob(p.Fs(), p.Join(pattern).String())
+}
+
+// Clean returns a new object that is a lexically-cleaned
+// version of Path.
+func (p *Path) Clean() *Path {
+	return NewPathAfero(filepath.Clean(p.String()), p.Fs())
+}
+
+// Mtime returns the modification time of the given path.
+func (p *Path) Mtime() (time.Time, error) {
+	stat, err := p.Stat()
+	if err != nil {
+		return time.Time{}, err
+	}
+	return Mtime(stat)
+}
+
+// Copy copies the path to another path using io.Copy.
+// Returned is the number of bytes copied and any error values.
+// The destination file is truncated if it exists, and is created
+// if it does not exist.
+func (p *Path) Copy(other *Path) (int64, error) {
+	srcFile, err := p.Open()
+	if err != nil {
+		return 0, fmt.Errorf("opening source file: %w", err)
+	}
+	defer srcFile.Close()
+	dstFile, err := other.OpenFile(os.O_TRUNC | os.O_CREATE | os.O_WRONLY)
+	if err != nil {
+		return 0, fmt.Errorf("opening destination file: %w", err)
+	}
+	defer dstFile.Close()
+	return io.Copy(dstFile, srcFile)
+}
+
+// Mtime returns the mtime described in the given os.FileInfo object
+func Mtime(fileInfo os.FileInfo) (time.Time, error) {
+	return fileInfo.ModTime(), nil
+}
+
+// Size returns the size of the object. Fails if the object doesn't exist.
+func (p *Path) Size() (int64, error) {
+	stat, err := p.Stat()
+	if err != nil {
+		return 0, err
+	}
+	return Size(stat), nil
+}
+
+// Size returns the size described by the os.FileInfo. Before you say anything,
+// yes... you could just do fileInfo.Size(). This is purely a convenience function
+// to create API consistency.
+func Size(fileInfo os.FileInfo) int64 {
+	return fileInfo.Size()
+}