migrate to go modules

3 files changed, 0 insertions, 334 deletions

diff --git a/vendor/github.com/99designs/gqlgen/internal/code/compare.go b/vendor/github.com/99designs/gqlgen/internal/code/compare.go
deleted file mode 100644
index dce9aea5..00000000
--- a/vendor/github.com/99designs/gqlgen/internal/code/compare.go
+++ /dev/null
@@ -1,163 +0,0 @@
-package code
-
-import (
-	"fmt"
-	"go/types"
-)
-
-// CompatibleTypes isnt a strict comparison, it allows for pointer differences
-func CompatibleTypes(expected types.Type, actual types.Type) error {
-	//fmt.Println("Comparing ", expected.String(), actual.String())
-
-	// Special case to deal with pointer mismatches
-	{
-		expectedPtr, expectedIsPtr := expected.(*types.Pointer)
-		actualPtr, actualIsPtr := actual.(*types.Pointer)
-
-		if expectedIsPtr && actualIsPtr {
-			return CompatibleTypes(expectedPtr.Elem(), actualPtr.Elem())
-		}
-		if expectedIsPtr && !actualIsPtr {
-			return CompatibleTypes(expectedPtr.Elem(), actual)
-		}
-		if !expectedIsPtr && actualIsPtr {
-			return CompatibleTypes(expected, actualPtr.Elem())
-		}
-	}
-
-	switch expected := expected.(type) {
-	case *types.Slice:
-		if actual, ok := actual.(*types.Slice); ok {
-			return CompatibleTypes(expected.Elem(), actual.Elem())
-		}
-
-	case *types.Array:
-		if actual, ok := actual.(*types.Array); ok {
-			if expected.Len() != actual.Len() {
-				return fmt.Errorf("array length differs")
-			}
-
-			return CompatibleTypes(expected.Elem(), actual.Elem())
-		}
-
-	case *types.Basic:
-		if actual, ok := actual.(*types.Basic); ok {
-			if actual.Kind() != expected.Kind() {
-				return fmt.Errorf("basic kind differs, %s != %s", expected.Name(), actual.Name())
-			}
-
-			return nil
-		}
-
-	case *types.Struct:
-		if actual, ok := actual.(*types.Struct); ok {
-			if expected.NumFields() != actual.NumFields() {
-				return fmt.Errorf("number of struct fields differ")
-			}
-
-			for i := 0; i < expected.NumFields(); i++ {
-				if expected.Field(i).Name() != actual.Field(i).Name() {
-					return fmt.Errorf("struct field %d name differs, %s != %s", i, expected.Field(i).Name(), actual.Field(i).Name())
-				}
-				if err := CompatibleTypes(expected.Field(i).Type(), actual.Field(i).Type()); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-
-	case *types.Tuple:
-		if actual, ok := actual.(*types.Tuple); ok {
-			if expected.Len() != actual.Len() {
-				return fmt.Errorf("tuple length differs, %d != %d", expected.Len(), actual.Len())
-			}
-
-			for i := 0; i < expected.Len(); i++ {
-				if err := CompatibleTypes(expected.At(i).Type(), actual.At(i).Type()); err != nil {
-					return err
-				}
-			}
-
-			return nil
-		}
-
-	case *types.Signature:
-		if actual, ok := actual.(*types.Signature); ok {
-			if err := CompatibleTypes(expected.Params(), actual.Params()); err != nil {
-				return err
-			}
-			if err := CompatibleTypes(expected.Results(), actual.Results()); err != nil {
-				return err
-			}
-
-			return nil
-		}
-	case *types.Interface:
-		if actual, ok := actual.(*types.Interface); ok {
-			if expected.NumMethods() != actual.NumMethods() {
-				return fmt.Errorf("interface method count differs, %d != %d", expected.NumMethods(), actual.NumMethods())
-			}
-
-			for i := 0; i < expected.NumMethods(); i++ {
-				if expected.Method(i).Name() != actual.Method(i).Name() {
-					return fmt.Errorf("interface method %d name differs, %s != %s", i, expected.Method(i).Name(), actual.Method(i).Name())
-				}
-				if err := CompatibleTypes(expected.Method(i).Type(), actual.Method(i).Type()); err != nil {
-					return err
-				}
-			}
-
-			return nil
-		}
-
-	case *types.Map:
-		if actual, ok := actual.(*types.Map); ok {
-			if err := CompatibleTypes(expected.Key(), actual.Key()); err != nil {
-				return err
-			}
-
-			if err := CompatibleTypes(expected.Elem(), actual.Elem()); err != nil {
-				return err
-			}
-
-			return nil
-		}
-
-	case *types.Chan:
-		if actual, ok := actual.(*types.Chan); ok {
-			return CompatibleTypes(expected.Elem(), actual.Elem())
-		}
-
-	case *types.Named:
-		if actual, ok := actual.(*types.Named); ok {
-			if NormalizeVendor(expected.Obj().Pkg().Path()) != NormalizeVendor(actual.Obj().Pkg().Path()) {
-				return fmt.Errorf(
-					"package name of named type differs, %s != %s",
-					NormalizeVendor(expected.Obj().Pkg().Path()),
-					NormalizeVendor(actual.Obj().Pkg().Path()),
-				)
-			}
-
-			if expected.Obj().Name() != actual.Obj().Name() {
-				return fmt.Errorf(
-					"named type name differs, %s != %s",
-					NormalizeVendor(expected.Obj().Name()),
-					NormalizeVendor(actual.Obj().Name()),
-				)
-			}
-
-			return nil
-		}
-
-		// Before models are generated all missing references will be Invalid Basic references.
-		// lets assume these are valid too.
-		if actual, ok := actual.(*types.Basic); ok && actual.Kind() == types.Invalid {
-			return nil
-		}
-
-	default:
-		return fmt.Errorf("missing support for %T", expected)
-	}
-
-	return fmt.Errorf("type mismatch %T != %T", expected, actual)
-}
diff --git a/vendor/github.com/99designs/gqlgen/internal/code/imports.go b/vendor/github.com/99designs/gqlgen/internal/code/imports.go
deleted file mode 100644
index ad62f7c5..00000000
--- a/vendor/github.com/99designs/gqlgen/internal/code/imports.go
+++ /dev/null
@@ -1,115 +0,0 @@
-package code
-
-import (
-	"errors"
-	"go/build"
-	"go/parser"
-	"go/token"
-	"io/ioutil"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"sync"
-
-	"golang.org/x/tools/go/packages"
-)
-
-var nameForPackageCache = sync.Map{}
-
-var gopaths []string
-
-func init() {
-	gopaths = filepath.SplitList(build.Default.GOPATH)
-	for i, p := range gopaths {
-		gopaths[i] = filepath.ToSlash(filepath.Join(p, "src"))
-	}
-}
-
-// NameForDir manually looks for package stanzas in files located in the given directory. This can be
-// much faster than having to consult go list, because we already know exactly where to look.
-func NameForDir(dir string) string {
-	dir, err := filepath.Abs(dir)
-	if err != nil {
-		return SanitizePackageName(filepath.Base(dir))
-	}
-	files, err := ioutil.ReadDir(dir)
-	if err != nil {
-		return SanitizePackageName(filepath.Base(dir))
-	}
-	fset := token.NewFileSet()
-	for _, file := range files {
-		if !strings.HasSuffix(strings.ToLower(file.Name()), ".go") {
-			continue
-		}
-
-		filename := filepath.Join(dir, file.Name())
-		if src, err := parser.ParseFile(fset, filename, nil, parser.PackageClauseOnly); err == nil {
-			return src.Name.Name
-		}
-	}
-
-	return SanitizePackageName(filepath.Base(dir))
-}
-
-// ImportPathForDir takes a path and returns a golang import path for the package
-func ImportPathForDir(dir string) (res string) {
-	dir, err := filepath.Abs(dir)
-	if err != nil {
-		panic(err)
-	}
-	dir = filepath.ToSlash(dir)
-
-	modDir := dir
-	assumedPart := ""
-	for {
-		f, err := ioutil.ReadFile(filepath.Join(modDir, "go.mod"))
-		if err == nil {
-			// found it, stop searching
-			return string(modregex.FindSubmatch(f)[1]) + assumedPart
-		}
-
-		assumedPart = "/" + filepath.Base(modDir) + assumedPart
-		parentDir, err := filepath.Abs(filepath.Join(modDir, ".."))
-		if err != nil {
-			panic(err)
-		}
-
-		if parentDir == modDir {
-			// Walked all the way to the root and didnt find anything :'(
-			break
-		}
-		modDir = parentDir
-	}
-
-	for _, gopath := range gopaths {
-		if len(gopath) < len(dir) && strings.EqualFold(gopath, dir[0:len(gopath)]) {
-			return dir[len(gopath)+1:]
-		}
-	}
-
-	return ""
-}
-
-var modregex = regexp.MustCompile("module (.*)\n")
-
-// NameForPackage returns the package name for a given import path. This can be really slow.
-func NameForPackage(importPath string) string {
-	if importPath == "" {
-		panic(errors.New("import path can not be empty"))
-	}
-	if v, ok := nameForPackageCache.Load(importPath); ok {
-		return v.(string)
-	}
-	importPath = QualifyPackagePath(importPath)
-	p, _ := packages.Load(&packages.Config{
-		Mode: packages.NeedName,
-	}, importPath)
-
-	if len(p) != 1 || p[0].Name == "" {
-		return SanitizePackageName(filepath.Base(importPath))
-	}
-
-	nameForPackageCache.Store(importPath, p[0].Name)
-
-	return p[0].Name
-}
diff --git a/vendor/github.com/99designs/gqlgen/internal/code/util.go b/vendor/github.com/99designs/gqlgen/internal/code/util.go
deleted file mode 100644
index 2be83a23..00000000
--- a/vendor/github.com/99designs/gqlgen/internal/code/util.go
+++ /dev/null
@@ -1,56 +0,0 @@
-package code
-
-import (
-	"go/build"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-)
-
-// take a string in the form github.com/package/blah.Type and split it into package and type
-func PkgAndType(name string) (string, string) {
-	parts := strings.Split(name, ".")
-	if len(parts) == 1 {
-		return "", name
-	}
-
-	return strings.Join(parts[:len(parts)-1], "."), parts[len(parts)-1]
-}
-
-var modsRegex = regexp.MustCompile(`^(\*|\[\])*`)
-
-// NormalizeVendor takes a qualified package path and turns it into normal one.
-// eg .
-// github.com/foo/vendor/github.com/99designs/gqlgen/graphql becomes
-// github.com/99designs/gqlgen/graphql
-func NormalizeVendor(pkg string) string {
-	modifiers := modsRegex.FindAllString(pkg, 1)[0]
-	pkg = strings.TrimPrefix(pkg, modifiers)
-	parts := strings.Split(pkg, "/vendor/")
-	return modifiers + parts[len(parts)-1]
-}
-
-// QualifyPackagePath takes an import and fully qualifies it with a vendor dir, if one is required.
-// eg .
-// github.com/99designs/gqlgen/graphql becomes
-// github.com/foo/vendor/github.com/99designs/gqlgen/graphql
-//
-// x/tools/packages only supports 'qualified package paths' so this will need to be done prior to calling it
-// See https://github.com/golang/go/issues/30289
-func QualifyPackagePath(importPath string) string {
-	wd, _ := os.Getwd()
-
-	pkg, err := build.Import(importPath, wd, 0)
-	if err != nil {
-		return importPath
-	}
-
-	return pkg.ImportPath
-}
-
-var invalidPackageNameChar = regexp.MustCompile(`[^\w]`)
-
-func SanitizePackageName(pkg string) string {
-	return invalidPackageNameChar.ReplaceAllLiteralString(filepath.Base(pkg), "_")
-}