go.mod, vendor: update (#3358)

* go.mod, vendor: remove unnecessary dependencies

Commands:
1. go mod tidy
2. go mod vendor

* go.mod, vendor: update cloud.google.com/go

Commands:
1. go get -u cloud.google.com/go
2. go mod tidy
3. go mod vendor

* go.mod, vendor: update cloud.google.com/*

Commands:
1. go get -u cloud.google.com/storage cloud.google.com/logging
2. go mod tidy
3. go mod vendor

* go.mod, .golangci.yml, vendor: update *lint*

Commands:
1. go get -u golang.org/x/tools github.com/golangci/golangci-lint@v1.47.0
2. go mod tidy
3. go mod vendor
4. edit .golangci.yml to suppress new errors (resolved in the same PR later)

* all: fix lint errors

hash.go: copy() recommended by gosimple
parse.go: ent is never nil
verifier.go: signal.Notify() with unbuffered channel is bad. Have no idea why.

* .golangci.yml: adjust godot rules

check-all is deprecated, but still work
if you're hesitating too - I'll remove this commit

26 files changed, 1096 insertions, 315 deletions

diff --git a/vendor/github.com/daixiang0/gci/pkg/config/config.go b/vendor/github.com/daixiang0/gci/pkg/config/config.go
new file mode 100644
index 000000000..b32148b18
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/config/config.go
@@ -0,0 +1,90 @@
+package config
+
+import (
+	"io/ioutil"
+	"sort"
+	"strings"
+
+	"gopkg.in/yaml.v3"
+
+	"github.com/daixiang0/gci/pkg/section"
+)
+
+var defaultOrder = map[string]int{
+	section.StandardType: 0,
+	section.DefaultType:  1,
+	section.CustomType:   2,
+	section.BlankType:    3,
+	section.DotType:      4,
+}
+
+type BoolConfig struct {
+	NoInlineComments bool `yaml:"no-inlineComments"`
+	NoPrefixComments bool `yaml:"no-prefixComments"`
+	Debug            bool `yaml:"-"`
+	SkipGenerated    bool `yaml:"skipGenerated"`
+	CustomOrder      bool `yaml:"customOrder"`
+}
+
+type Config struct {
+	BoolConfig
+	Sections          section.SectionList
+	SectionSeparators section.SectionList
+}
+
+type YamlConfig struct {
+	Cfg                     BoolConfig `yaml:",inline"`
+	SectionStrings          []string   `yaml:"sections"`
+	SectionSeparatorStrings []string   `yaml:"sectionseparators"`
+}
+
+func (g YamlConfig) Parse() (*Config, error) {
+	var err error
+
+	sections, err := section.Parse(g.SectionStrings)
+	if err != nil {
+		return nil, err
+	}
+	if sections == nil {
+		sections = section.DefaultSections()
+	}
+
+	// if default order sorted sections
+	if !g.Cfg.CustomOrder {
+		sort.Slice(sections, func(i, j int) bool {
+			sectionI, sectionJ := sections[i].Type(), sections[j].Type()
+
+			if strings.Compare(sectionI, sectionJ) == 0 {
+				return strings.Compare(sections[i].String(), sections[j].String()) < 0
+			}
+			return defaultOrder[sectionI] < defaultOrder[sectionJ]
+		})
+	}
+
+	sectionSeparators, err := section.Parse(g.SectionSeparatorStrings)
+	if err != nil {
+		return nil, err
+	}
+	if sectionSeparators == nil {
+		sectionSeparators = section.DefaultSectionSeparators()
+	}
+
+	return &Config{g.Cfg, sections, sectionSeparators}, nil
+}
+
+func InitializeGciConfigFromYAML(filePath string) (*Config, error) {
+	config := YamlConfig{}
+	yamlData, err := ioutil.ReadFile(filePath)
+	if err != nil {
+		return nil, err
+	}
+	err = yaml.Unmarshal(yamlData, &config)
+	if err != nil {
+		return nil, err
+	}
+	gciCfg, err := config.Parse()
+	if err != nil {
+		return nil, err
+	}
+	return gciCfg, nil
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/format/format.go b/vendor/github.com/daixiang0/gci/pkg/format/format.go
new file mode 100644
index 000000000..062701d2e
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/format/format.go
@@ -0,0 +1,46 @@
+package format
+
+import (
+	"fmt"
+
+	"github.com/daixiang0/gci/pkg/config"
+	"github.com/daixiang0/gci/pkg/log"
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/section"
+	"github.com/daixiang0/gci/pkg/specificity"
+)
+
+type Block struct {
+	Start, End int
+}
+
+type resultMap map[string][]*Block
+
+func Format(data []*parse.GciImports, cfg *config.Config) (resultMap, error) {
+	result := make(resultMap, len(cfg.Sections))
+	for _, d := range data {
+		// determine match specificity for every available section
+		var bestSection section.Section
+		var bestSectionSpecificity specificity.MatchSpecificity = specificity.MisMatch{}
+		for _, section := range cfg.Sections {
+			sectionSpecificity := section.MatchSpecificity(d)
+			if sectionSpecificity.IsMoreSpecific(specificity.MisMatch{}) && sectionSpecificity.Equal(bestSectionSpecificity) {
+				// specificity is identical
+				// return nil, section.EqualSpecificityMatchError{}
+				return nil, nil
+			}
+			if sectionSpecificity.IsMoreSpecific(bestSectionSpecificity) {
+				// better match found
+				bestSectionSpecificity = sectionSpecificity
+				bestSection = section
+			}
+		}
+		if bestSection == nil {
+			return nil, section.NoMatchingSectionForImportError{Imports: d}
+		}
+		log.L().Debug(fmt.Sprintf("Matched import %v to section %s", d, bestSection))
+		result[bestSection.String()] = append(result[bestSection.String()], &Block{d.Start, d.End})
+	}
+
+	return result, nil
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/gci/gci.go b/vendor/github.com/daixiang0/gci/pkg/gci/gci.go
index 7e31b870b..a8a64a278 100644
--- a/vendor/github.com/daixiang0/gci/pkg/gci/gci.go
+++ b/vendor/github.com/daixiang0/gci/pkg/gci/gci.go
@@ -2,367 +2,189 @@ package gci
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
-	"io"
-	"io/ioutil"
 	"os"
-	"os/exec"
-	"path/filepath"
-	"sort"
-	"strings"
+	"sync"
+
+	"github.com/hexops/gotextdiff"
+	"github.com/hexops/gotextdiff/myers"
+	"github.com/hexops/gotextdiff/span"
+	"golang.org/x/sync/errgroup"
+
+	"github.com/daixiang0/gci/pkg/config"
+	"github.com/daixiang0/gci/pkg/format"
+	"github.com/daixiang0/gci/pkg/io"
+	"github.com/daixiang0/gci/pkg/log"
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/section"
+	"github.com/daixiang0/gci/pkg/utils"
 )
 
-const (
-	// pkg type: standard, remote, local
-	standard int = iota
-	// 3rd-party packages
-	remote
-	local
-
-	commentFlag = "//"
-)
-
-var (
-	importStartFlag = []byte(`
-import (
-`)
-	importEndFlag = []byte(`
-)
-`)
-)
-
-type FlagSet struct {
-	LocalFlag       string
-	DoWrite, DoDiff *bool
+func LocalFlagsToSections(localFlags []string) section.SectionList {
+	sections := section.DefaultSections()
+	// Add all local arguments as ImportPrefix sections
+	// for _, l := range localFlags {
+	// 	sections = append(sections, section.Section{l, nil, nil})
+	// }
+	return sections
 }
 
-type pkg struct {
-	list    map[int][]string
-	comment map[string]string
-	alias   map[string]string
+func PrintFormattedFiles(paths []string, cfg config.Config) error {
+	return processStdInAndGoFilesInPaths(paths, cfg, func(filePath string, unmodifiedFile, formattedFile []byte) error {
+		fmt.Print(string(formattedFile))
+		return nil
+	})
 }
 
-func newPkg(data [][]byte, localFlag string) *pkg {
-	listMap := make(map[int][]string)
-	commentMap := make(map[string]string)
-	aliasMap := make(map[string]string)
-	p := &pkg{
-		list:    listMap,
-		comment: commentMap,
-		alias:   aliasMap,
-	}
-
-	formatData := make([]string, 0)
-	// remove all empty lines
-	for _, v := range data {
-		if len(v) > 0 {
-			formatData = append(formatData, strings.TrimSpace(string(v)))
+func WriteFormattedFiles(paths []string, cfg config.Config) error {
+	return processGoFilesInPaths(paths, cfg, func(filePath string, unmodifiedFile, formattedFile []byte) error {
+		if bytes.Equal(unmodifiedFile, formattedFile) {
+			log.L().Debug(fmt.Sprintf("Skipping correctly formatted File: %s", filePath))
+			return nil
 		}
-	}
-
-	n := len(formatData)
-	for i := n - 1; i >= 0; i-- {
-		line := formatData[i]
-
-		// check commentFlag:
-		// 1. one line commentFlag
-		// 2. commentFlag after import path
-		commentIndex := strings.Index(line, commentFlag)
-		if commentIndex == 0 {
-			// comment in the last line is useless, ignore it
-			if i+1 >= n {
-				continue
-			}
-			pkg, _, _ := getPkgInfo(formatData[i+1], strings.Index(formatData[i+1], commentFlag) >= 0)
-			p.comment[pkg] = line
-			continue
-		} else if commentIndex > 0 {
-			pkg, alias, comment := getPkgInfo(line, true)
-			if alias != "" {
-				p.alias[pkg] = alias
-			}
-
-			p.comment[pkg] = comment
-			pkgType := getPkgType(pkg, localFlag)
-			p.list[pkgType] = append(p.list[pkgType], pkg)
-			continue
-		}
-
-		pkg, alias, _ := getPkgInfo(line, false)
-
-		if alias != "" {
-			p.alias[pkg] = alias
-		}
-
-		pkgType := getPkgType(pkg, localFlag)
-		p.list[pkgType] = append(p.list[pkgType], pkg)
-	}
-
-	return p
+		log.L().Info(fmt.Sprintf("Writing formatted File: %s", filePath))
+		return os.WriteFile(filePath, formattedFile, 0o644)
+	})
 }
 
-// fmt format import pkgs as expected
-func (p *pkg) fmt() []byte {
-	ret := make([]string, 0, 100)
-
-	for pkgType := range []int{standard, remote, local} {
-		sort.Strings(p.list[pkgType])
-		for _, s := range p.list[pkgType] {
-			if p.comment[s] != "" {
-				l := fmt.Sprintf("%s%s%s%s", linebreak, indent, p.comment[s], linebreak)
-				ret = append(ret, l)
-			}
-
-			if p.alias[s] != "" {
-				s = fmt.Sprintf("%s%s%s%s%s", indent, p.alias[s], blank, s, linebreak)
-			} else {
-				s = fmt.Sprintf("%s%s%s", indent, s, linebreak)
-			}
-
-			ret = append(ret, s)
-		}
-
-		if len(p.list[pkgType]) > 0 {
-			ret = append(ret, linebreak)
-		}
-	}
-	if ret[len(ret)-1] == linebreak {
-		ret = ret[:len(ret)-1]
-	}
-
-	// remove duplicate empty lines
-	s1 := fmt.Sprintf("%s%s%s%s", linebreak, linebreak, linebreak, indent)
-	s2 := fmt.Sprintf("%s%s%s", linebreak, linebreak, indent)
-	return []byte(strings.ReplaceAll(strings.Join(ret, ""), s1, s2))
+func DiffFormattedFiles(paths []string, cfg config.Config) error {
+	return processStdInAndGoFilesInPaths(paths, cfg, func(filePath string, unmodifiedFile, formattedFile []byte) error {
+		fileURI := span.URIFromPath(filePath)
+		edits := myers.ComputeEdits(fileURI, string(unmodifiedFile), string(formattedFile))
+		unifiedEdits := gotextdiff.ToUnified(filePath, filePath, string(unmodifiedFile), edits)
+		fmt.Printf("%v", unifiedEdits)
+		return nil
+	})
 }
 
-// getPkgInfo assume line is a import path, and return (path, alias, comment)
-func getPkgInfo(line string, comment bool) (string, string, string) {
-	if comment {
-		s := strings.Split(line, commentFlag)
-		pkgArray := strings.Split(s[0], blank)
-		if len(pkgArray) > 1 {
-			return pkgArray[1], pkgArray[0], fmt.Sprintf("%s%s%s", commentFlag, blank, strings.TrimSpace(s[1]))
-		} else {
-			return strings.TrimSpace(pkgArray[0]), "", fmt.Sprintf("%s%s%s", commentFlag, blank, strings.TrimSpace(s[1]))
-		}
-	} else {
-		pkgArray := strings.Split(line, blank)
-		if len(pkgArray) > 1 {
-			return pkgArray[1], pkgArray[0], ""
-		} else {
-			return pkgArray[0], "", ""
-		}
-	}
+func DiffFormattedFilesToArray(paths []string, cfg config.Config, diffs *[]string, lock *sync.Mutex) error {
+	log.InitLogger()
+	defer log.L().Sync()
+	return processStdInAndGoFilesInPaths(paths, cfg, func(filePath string, unmodifiedFile, formattedFile []byte) error {
+		fileURI := span.URIFromPath(filePath)
+		edits := myers.ComputeEdits(fileURI, string(unmodifiedFile), string(formattedFile))
+		unifiedEdits := gotextdiff.ToUnified(filePath, filePath, string(unmodifiedFile), edits)
+		lock.Lock()
+		*diffs = append(*diffs, fmt.Sprint(unifiedEdits))
+		lock.Unlock()
+		return nil
+	})
 }
 
-func getPkgType(line, localFlag string) int {
-	pkgName := strings.Trim(line, "\"\\`")
-
-	if localFlag != "" && strings.HasPrefix(pkgName, localFlag) {
-		return local
-	}
-
-	if isStandardPackage(pkgName) {
-		return standard
-	}
+type fileFormattingFunc func(filePath string, unmodifiedFile, formattedFile []byte) error
 
-	return remote
+func processStdInAndGoFilesInPaths(paths []string, cfg config.Config, fileFunc fileFormattingFunc) error {
+	return ProcessFiles(io.StdInGenerator.Combine(io.GoFilesInPathsGenerator(paths)), cfg, fileFunc)
 }
 
-const (
-	blank     = " "
-	indent    = "\t"
-	linebreak = "\n"
-)
+func processGoFilesInPaths(paths []string, cfg config.Config, fileFunc fileFormattingFunc) error {
+	return ProcessFiles(io.GoFilesInPathsGenerator(paths), cfg, fileFunc)
+}
 
-func diff(b1, b2 []byte, filename string) (data []byte, err error) {
-	f1, err := writeTempFile("", "gci", b1)
+func ProcessFiles(fileGenerator io.FileGeneratorFunc, cfg config.Config, fileFunc fileFormattingFunc) error {
+	var taskGroup errgroup.Group
+	files, err := fileGenerator()
 	if err != nil {
-		return
+		return err
 	}
-	defer os.Remove(f1)
-
-	f2, err := writeTempFile("", "gci", b2)
-	if err != nil {
-		return
+	for _, file := range files {
+		// run file processing in parallel
+		taskGroup.Go(processingFunc(file, cfg, fileFunc))
 	}
-	defer os.Remove(f2)
-
-	cmd := "diff"
+	return taskGroup.Wait()
+}
 
-	data, err = exec.Command(cmd, "-u", f1, f2).CombinedOutput()
-	if len(data) > 0 {
-		// diff exits with a non-zero status when the files don't match.
-		// Ignore that failure as long as we get output.
-		return replaceTempFilename(data, filename)
+func processingFunc(file io.FileObj, cfg config.Config, formattingFunc fileFormattingFunc) func() error {
+	return func() error {
+		unmodifiedFile, formattedFile, err := LoadFormatGoFile(file, cfg)
+		if err != nil {
+			// if errors.Is(err, FileParsingError{}) {
+			// 	// do not process files that are improperly formatted
+			// 	return nil
+			// }
+			return err
+		}
+		return formattingFunc(file.Path(), unmodifiedFile, formattedFile)
 	}
-	return
 }
 
-func writeTempFile(dir, prefix string, data []byte) (string, error) {
-	file, err := ioutil.TempFile(dir, prefix)
-	if err != nil {
-		return "", err
-	}
-	_, err = file.Write(data)
-	if err1 := file.Close(); err == nil {
-		err = err1
-	}
+func LoadFormatGoFile(file io.FileObj, cfg config.Config) (src, dist []byte, err error) {
+	src, err = file.Load()
+	log.L().Debug(fmt.Sprintf("Loaded File: %s", file.Path()))
 	if err != nil {
-		os.Remove(file.Name())
-		return "", err
+		return nil, nil, err
 	}
-	return file.Name(), nil
-}
 
-// replaceTempFilename replaces temporary filenames in diff with actual one.
-//
-// --- /tmp/gofmt316145376	2017-02-03 19:13:00.280468375 -0500
-// +++ /tmp/gofmt617882815	2017-02-03 19:13:00.280468375 -0500
-// ...
-// ->
-// --- path/to/file.go.orig	2017-02-03 19:13:00.280468375 -0500
-// +++ path/to/file.go	2017-02-03 19:13:00.280468375 -0500
-// ...
-func replaceTempFilename(diff []byte, filename string) ([]byte, error) {
-	bs := bytes.SplitN(diff, []byte{'\n'}, 3)
-	if len(bs) < 3 {
-		return nil, fmt.Errorf("got unexpected diff for %s", filename)
+	if cfg.SkipGenerated && parse.IsGeneratedFileByComment(string(src)) {
+		return src, src, nil
 	}
-	// Preserve timestamps.
-	var t0, t1 []byte
-	if i := bytes.LastIndexByte(bs[0], '\t'); i != -1 {
-		t0 = bs[0][i:]
-	}
-	if i := bytes.LastIndexByte(bs[1], '\t'); i != -1 {
-		t1 = bs[1][i:]
-	}
-	// Always print filepath with slash separator.
-	f := filepath.ToSlash(filename)
-	bs[0] = []byte(fmt.Sprintf("--- %s%s", f+".orig", t0))
-	bs[1] = []byte(fmt.Sprintf("+++ %s%s", f, t1))
-	return bytes.Join(bs, []byte{'\n'}), nil
-}
 
-func visitFile(set *FlagSet) filepath.WalkFunc {
-	return func(path string, f os.FileInfo, err error) error {
-		if err == nil && isGoFile(f) {
-			err = processFile(path, os.Stdout, set)
+	imports, headEnd, tailStart, err := parse.ParseFile(src, file.Path())
+	if err != nil {
+		if errors.Is(err, parse.NoImportError{}) {
+			return src, src, nil
 		}
-		return err
+		return nil, nil, err
 	}
-}
-
-func WalkDir(path string, set *FlagSet) error {
-	return filepath.Walk(path, visitFile(set))
-}
 
-func isGoFile(f os.FileInfo) bool {
-	// ignore non-Go files
-	name := f.Name()
-	return !f.IsDir() && !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".go")
-}
-
-func ProcessFile(filename string, out io.Writer, set *FlagSet) error {
-	return processFile(filename, out, set)
-}
-
-func processFile(filename string, out io.Writer, set *FlagSet) error {
-	var err error
-
-	f, err := os.Open(filename)
-	if err != nil {
-		return err
+	// do not do format if only one import
+	if len(imports) == 1 {
+		return src, src, nil
 	}
-	defer f.Close()
 
-	src, err := ioutil.ReadAll(f)
+	result, err := format.Format(imports, &cfg)
 	if err != nil {
-		return err
-	}
-
-	ori := make([]byte, len(src))
-	copy(ori, src)
-	start := bytes.Index(src, importStartFlag)
-	// in case no importStartFlag or importStartFlag exist in the commentFlag
-	if start < 0 {
-		fmt.Printf("skip file %s since no import\n", filename)
-		return nil
+		return nil, nil, err
 	}
-	end := bytes.Index(src[start:], importEndFlag) + start
 
-	ret := bytes.Split(src[start+len(importStartFlag):end], []byte(linebreak))
+	head := src[:headEnd]
+	tail := src[tailStart:]
 
-	p := newPkg(ret, set.LocalFlag)
+	firstWithIndex := true
 
-	res := append(src[:start+len(importStartFlag)], append(p.fmt(), src[end+1:]...)...)
+	var body []byte
 
-	if !bytes.Equal(ori, res) {
-		if *set.DoWrite {
-			// On Windows, we need to re-set the permissions from the file. See golang/go#38225.
-			var perms os.FileMode
-			if fi, err := os.Stat(filename); err == nil {
-				perms = fi.Mode() & os.ModePerm
+	// order by section list
+	for _, s := range cfg.Sections {
+		if len(result[s.String()]) > 0 {
+			if body != nil && len(body) > 0 {
+				body = append(body, utils.Linebreak)
 			}
-			err = ioutil.WriteFile(filename, res, perms)
-			if err != nil {
-				return err
-			}
-		}
-		if *set.DoDiff {
-			data, err := diff(ori, res, filename)
-			if err != nil {
-				return fmt.Errorf("failed to diff: %v", err)
-			}
-			fmt.Printf("diff -u %s %s\n", filepath.ToSlash(filename+".orig"), filepath.ToSlash(filename))
-			if _, err := out.Write(data); err != nil {
-				return fmt.Errorf("failed to write: %v", err)
+			for _, d := range result[s.String()] {
+				AddIndent(&body, &firstWithIndex)
+				body = append(body, src[d.Start:d.End]...)
 			}
 		}
 	}
-	if !*set.DoWrite && !*set.DoDiff {
-		if _, err = out.Write(res); err != nil {
-			return fmt.Errorf("failed to write: %v", err)
-		}
-	}
-
-	return err
-}
-
-// Run return source and result in []byte if succeed
-func Run(filename string, set *FlagSet) ([]byte, []byte, error) {
-	var err error
 
-	f, err := os.Open(filename)
-	if err != nil {
-		return nil, nil, err
+	// remove breakline in the end
+	for body[len(body)-1] == utils.Linebreak {
+		body = body[:len(body)-1]
 	}
-	defer f.Close()
 
-	src, err := ioutil.ReadAll(f)
-	if err != nil {
-		return nil, nil, err
+	if tail[0] != utils.Linebreak {
+		body = append(body, utils.Linebreak)
 	}
 
-	ori := make([]byte, len(src))
-	copy(ori, src)
-	start := bytes.Index(src, importStartFlag)
-	// in case no importStartFlag or importStartFlag exist in the commentFlag
-	if start < 0 {
-		return nil, nil, nil
+	var totalLen int
+	slices := [][]byte{head, body, tail}
+	for _, s := range slices {
+		totalLen += len(s)
+	}
+	dist = make([]byte, totalLen)
+	var i int
+	for _, s := range slices {
+		i += copy(dist[i:], s)
 	}
-	end := bytes.Index(src[start:], importEndFlag) + start
-
-	ret := bytes.Split(src[start+len(importStartFlag):end], []byte(linebreak))
-
-	p := newPkg(ret, set.LocalFlag)
 
-	res := append(src[:start+len(importStartFlag)], append(p.fmt(), src[end+1:]...)...)
+	return src, dist, nil
+}
 
-	if bytes.Equal(ori, res) {
-		return ori, nil, nil
+func AddIndent(in *[]byte, first *bool) {
+	if *first {
+		*first = false
+		return
 	}
-
-	return ori, res, nil
+	*in = append(*in, utils.Indent)
 }
diff --git a/vendor/github.com/daixiang0/gci/pkg/io/file.go b/vendor/github.com/daixiang0/gci/pkg/io/file.go
new file mode 100644
index 000000000..f92d16e14
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/io/file.go
@@ -0,0 +1,59 @@
+package io
+
+import "io/ioutil"
+
+// FileObj allows mocking the access to files
+type FileObj interface {
+	Load() ([]byte, error)
+	Path() string
+}
+
+// File represents a file that can be loaded from the file system
+type File struct {
+	FilePath string
+}
+
+func (f File) Path() string {
+	return f.FilePath
+}
+
+func (f File) Load() ([]byte, error) {
+	return ioutil.ReadFile(f.FilePath)
+}
+
+// FileGeneratorFunc returns a list of files that can be loaded and processed
+type FileGeneratorFunc func() ([]FileObj, error)
+
+func (a FileGeneratorFunc) Combine(b FileGeneratorFunc) FileGeneratorFunc {
+	return func() ([]FileObj, error) {
+		files, err := a()
+		if err != nil {
+			return nil, err
+		}
+		additionalFiles, err := b()
+		if err != nil {
+			return nil, err
+		}
+		files = append(files, additionalFiles...)
+		return files, err
+	}
+}
+
+func GoFilesInPathsGenerator(paths []string) FileGeneratorFunc {
+	return FilesInPathsGenerator(paths, isGoFile)
+}
+
+func FilesInPathsGenerator(paths []string, fileCheckFun fileCheckFunction) FileGeneratorFunc {
+	return func() (foundFiles []FileObj, err error) {
+		for _, path := range paths {
+			files, err := FindFilesForPath(path, fileCheckFun)
+			if err != nil {
+				return nil, err
+			}
+			for _, filePath := range files {
+				foundFiles = append(foundFiles, File{filePath})
+			}
+		}
+		return foundFiles, nil
+	}
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/io/search.go b/vendor/github.com/daixiang0/gci/pkg/io/search.go
new file mode 100644
index 000000000..04f005876
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/io/search.go
@@ -0,0 +1,47 @@
+package io
+
+import (
+	"io/fs"
+	"os"
+	"path/filepath"
+)
+
+type fileCheckFunction func(file os.FileInfo) bool
+
+func FindFilesForPath(path string, fileCheckFun fileCheckFunction) ([]string, error) {
+	switch entry, err := os.Stat(path); {
+	case err != nil:
+		return nil, err
+	case entry.IsDir():
+		return findFilesForDirectory(path, fileCheckFun)
+	case fileCheckFun(entry):
+		return []string{filepath.Clean(path)}, nil
+	default:
+		return []string{}, nil
+	}
+}
+
+func findFilesForDirectory(dirPath string, fileCheckFun fileCheckFunction) ([]string, error) {
+	var filePaths []string
+	err := filepath.WalkDir(dirPath, func(path string, entry fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		file, err := entry.Info()
+		if err != nil {
+			return err
+		}
+		if !entry.IsDir() && fileCheckFun(file) {
+			filePaths = append(filePaths, filepath.Clean(path))
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
+	}
+	return filePaths, nil
+}
+
+func isGoFile(file os.FileInfo) bool {
+	return !file.IsDir() && filepath.Ext(file.Name()) == ".go"
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/io/stdin.go b/vendor/github.com/daixiang0/gci/pkg/io/stdin.go
new file mode 100644
index 000000000..ccab2844f
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/io/stdin.go
@@ -0,0 +1,27 @@
+package io
+
+import (
+	"io/ioutil"
+	"os"
+)
+
+type stdInFile struct{}
+
+func (s stdInFile) Load() ([]byte, error) {
+	return ioutil.ReadAll(os.Stdin)
+}
+
+func (s stdInFile) Path() string {
+	return "StdIn"
+}
+
+var StdInGenerator FileGeneratorFunc = func() ([]FileObj, error) {
+	stat, err := os.Stdin.Stat()
+	if err != nil {
+		return nil, err
+	}
+	if (stat.Mode() & os.ModeCharDevice) == 0 {
+		return []FileObj{stdInFile{}}, nil
+	}
+	return []FileObj{}, nil
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/log/log.go b/vendor/github.com/daixiang0/gci/pkg/log/log.go
new file mode 100644
index 000000000..ab33739ca
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/log/log.go
@@ -0,0 +1,50 @@
+package log
+
+import (
+	"sync"
+
+	"go.uber.org/zap"
+	"go.uber.org/zap/zapcore"
+)
+
+// Use L to log with Zap
+var logger *zap.Logger
+
+// Keep the config to reference the atomicLevel for changing levels
+var logConfig zap.Config
+
+var doOnce sync.Once
+
+// InitLogger sets up the logger
+func InitLogger() {
+	doOnce.Do(func() {
+		logConfig = zap.NewDevelopmentConfig()
+
+		logConfig.EncoderConfig.TimeKey = "timestamp"
+		logConfig.EncoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
+		logConfig.Level.SetLevel(zapcore.InfoLevel)
+		logConfig.OutputPaths = []string{"stderr"}
+
+		var err error
+		logger, err = logConfig.Build()
+		if err != nil {
+			panic(err)
+		}
+	})
+}
+
+// SetLevel allows you to set the level of the default gci logger.
+// This will not work if you replace the logger
+func SetLevel(level zapcore.Level) {
+	logConfig.Level.SetLevel(level)
+}
+
+// L returns the logger
+func L() *zap.Logger {
+	return logger
+}
+
+// SetLogger allows you to set the logger to whatever you want
+func SetLogger(l *zap.Logger) {
+	logger = l
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/parse/parse.go b/vendor/github.com/daixiang0/gci/pkg/parse/parse.go
new file mode 100644
index 000000000..d84ed1335
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/parse/parse.go
@@ -0,0 +1,139 @@
+package parse
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"sort"
+	"strings"
+)
+
+type GciImports struct {
+	// original index of import group, include doc, name, path and comment
+	Start, End int
+	Name, Path string
+}
+type ImportList []*GciImports
+
+func (l ImportList) Len() int {
+	return len(l)
+}
+
+func (l ImportList) Less(i, j int) bool {
+	if strings.Compare(l[i].Path, l[j].Path) == 0 {
+		return strings.Compare(l[i].Name, l[j].Name) < 0
+	}
+
+	return strings.Compare(l[i].Path, l[j].Path) < 0
+}
+
+func (l ImportList) Swap(i, j int) { l[i], l[j] = l[j], l[i] }
+
+/*
+ * AST considers a import block as below:
+ * ```
+ * Doc
+ * Name Path Comment
+ * ```
+ * An example is like below:
+ * ```
+ * // test
+ * test "fmt" // test
+ * ```
+ * getImports return a import block with name, start and end index
+ */
+func getImports(imp *ast.ImportSpec) (start, end int, name string) {
+	if imp.Doc != nil {
+		// doc poc need minus one to get the first index of comment
+		start = int(imp.Doc.Pos()) - 1
+	} else {
+		if imp.Name != nil {
+			// name pos need minus one too
+			start = int(imp.Name.Pos()) - 1
+		} else {
+			// path pos start without quote, need minus one for it
+			start = int(imp.Path.Pos()) - 1
+		}
+	}
+
+	if imp.Name != nil {
+		name = imp.Name.Name
+	}
+
+	if imp.Comment != nil {
+		end = int(imp.Comment.End())
+	} else {
+		end = int(imp.Path.End())
+	}
+	return
+}
+
+func ParseFile(src []byte, filename string) (ImportList, int, int, error) {
+	fileSet := token.NewFileSet()
+	f, err := parser.ParseFile(fileSet, filename, src, parser.ParseComments)
+	if err != nil {
+		return nil, 0, 0, err
+	}
+
+	if len(f.Imports) == 0 {
+		return nil, 0, 0, NoImportError{}
+	}
+
+	var headEnd int
+	var tailStart int
+
+	var data ImportList
+	for i, imp := range f.Imports {
+		start, end, name := getImports(imp)
+
+		if i == 0 {
+			headEnd = start
+		}
+		if i == len(f.Imports)-1 {
+			tailStart = end
+		}
+
+		data = append(data, &GciImports{
+			Start: start,
+			End:   end,
+			Name:  name,
+			Path:  strings.Trim(imp.Path.Value, `"`),
+		})
+	}
+
+	sort.Sort(data)
+	return data, headEnd, tailStart, nil
+}
+
+// IsGeneratedFileByComment reports whether the source file is generated code.
+// Using a bit laxer rules than https://golang.org/s/generatedcode to
+// match more generated code.
+// Taken from https://github.com/golangci/golangci-lint.
+func IsGeneratedFileByComment(in string) bool {
+	const (
+		genCodeGenerated = "code generated"
+		genDoNotEdit     = "do not edit"
+		genAutoFile      = "autogenerated file" // easyjson
+	)
+
+	markers := []string{genCodeGenerated, genDoNotEdit, genAutoFile}
+	in = strings.ToLower(in)
+	for _, marker := range markers {
+		if strings.Contains(in, marker) {
+			return true
+		}
+	}
+
+	return false
+}
+
+type NoImportError struct{}
+
+func (n NoImportError) Error() string {
+	return "No imports"
+}
+
+func (i NoImportError) Is(err error) bool {
+	_, ok := err.(NoImportError)
+	return ok
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/blank.go b/vendor/github.com/daixiang0/gci/pkg/section/blank.go
new file mode 100644
index 000000000..4a2741773
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/blank.go
@@ -0,0 +1,25 @@
+package section
+
+import (
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/specificity"
+)
+
+type Blank struct{}
+
+const BlankType = "blank"
+
+func (b Blank) MatchSpecificity(spec *parse.GciImports) specificity.MatchSpecificity {
+	if spec.Name == "_" {
+		return specificity.NameMatch{}
+	}
+	return specificity.MisMatch{}
+}
+
+func (b Blank) String() string {
+	return BlankType
+}
+
+func (b Blank) Type() string {
+	return BlankType
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/commentline.go b/vendor/github.com/daixiang0/gci/pkg/section/commentline.go
new file mode 100644
index 000000000..c3ddd0824
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/commentline.go
@@ -0,0 +1,24 @@
+package section
+
+import (
+	"fmt"
+
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/specificity"
+)
+
+type CommentLine struct {
+	Comment string
+}
+
+func (c CommentLine) MatchSpecificity(spec *parse.GciImports) specificity.MatchSpecificity {
+	return specificity.MisMatch{}
+}
+
+func (c CommentLine) String() string {
+	return fmt.Sprintf("commentline(%s)", c.Comment)
+}
+
+func (c CommentLine) Type() string {
+	return "commentline"
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/default.go b/vendor/github.com/daixiang0/gci/pkg/section/default.go
new file mode 100644
index 000000000..3af07a092
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/default.go
@@ -0,0 +1,22 @@
+package section
+
+import (
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/specificity"
+)
+
+const DefaultType = "default"
+
+type Default struct{}
+
+func (d Default) MatchSpecificity(spec *parse.GciImports) specificity.MatchSpecificity {
+	return specificity.Default{}
+}
+
+func (d Default) String() string {
+	return DefaultType
+}
+
+func (d Default) Type() string {
+	return DefaultType
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/dot.go b/vendor/github.com/daixiang0/gci/pkg/section/dot.go
new file mode 100644
index 000000000..8112eeb1d
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/dot.go
@@ -0,0 +1,25 @@
+package section
+
+import (
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/specificity"
+)
+
+type Dot struct{}
+
+const DotType = "dot"
+
+func (d Dot) MatchSpecificity(spec *parse.GciImports) specificity.MatchSpecificity {
+	if spec.Name == "." {
+		return specificity.NameMatch{}
+	}
+	return specificity.MisMatch{}
+}
+
+func (d Dot) String() string {
+	return DotType
+}
+
+func (d Dot) Type() string {
+	return DotType
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/errors.go b/vendor/github.com/daixiang0/gci/pkg/section/errors.go
new file mode 100644
index 000000000..1aa42ecdf
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/errors.go
@@ -0,0 +1,107 @@
+package section
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/utils"
+)
+
+type SectionParsingError struct {
+	error
+}
+
+func (s SectionParsingError) Unwrap() error {
+	return s.error
+}
+
+func (s SectionParsingError) Wrap(sectionStr string) error {
+	return fmt.Errorf("failed to parse section %q: %w", sectionStr, s)
+}
+
+func (s SectionParsingError) Is(err error) bool {
+	_, ok := err.(SectionParsingError)
+	return ok
+}
+
+var MissingParameterClosingBracketsError = fmt.Errorf("section parameter is missing closing %q", utils.ParameterClosingBrackets)
+
+var MoreThanOneOpeningQuotesError = fmt.Errorf("found more than one %q parameter start sequences", utils.ParameterClosingBrackets)
+
+var SectionTypeDoesNotAcceptParametersError = errors.New("section type does not accept a parameter")
+
+var SectionTypeDoesNotAcceptPrefixError = errors.New("section may not contain a Prefix")
+
+var SectionTypeDoesNotAcceptSuffixError = errors.New("section may not contain a Suffix")
+
+type EqualSpecificityMatchError struct {
+	Imports            *parse.GciImports
+	SectionA, SectionB Section
+}
+
+func (e EqualSpecificityMatchError) Error() string {
+	return fmt.Sprintf("Import %v matched section %s and %s equally", e.Imports, e.SectionA, e.SectionB)
+}
+
+func (e EqualSpecificityMatchError) Is(err error) bool {
+	_, ok := err.(EqualSpecificityMatchError)
+	return ok
+}
+
+type NoMatchingSectionForImportError struct {
+	Imports *parse.GciImports
+}
+
+func (n NoMatchingSectionForImportError) Error() string {
+	return fmt.Sprintf("No section found for Import: %v", n.Imports)
+}
+
+func (n NoMatchingSectionForImportError) Is(err error) bool {
+	_, ok := err.(NoMatchingSectionForImportError)
+	return ok
+}
+
+type InvalidImportSplitError struct {
+	segments []string
+}
+
+func (i InvalidImportSplitError) Error() string {
+	return fmt.Sprintf("separating the inline comment from the import yielded an invalid number of segments: %v", i.segments)
+}
+
+func (i InvalidImportSplitError) Is(err error) bool {
+	_, ok := err.(InvalidImportSplitError)
+	return ok
+}
+
+type InvalidAliasSplitError struct {
+	segments []string
+}
+
+func (i InvalidAliasSplitError) Error() string {
+	return fmt.Sprintf("separating the alias from the path yielded an invalid number of segments: %v", i.segments)
+}
+
+func (i InvalidAliasSplitError) Is(err error) bool {
+	_, ok := err.(InvalidAliasSplitError)
+	return ok
+}
+
+var (
+	MissingImportStatementError   = FileParsingError{errors.New("no import statement present in File")}
+	ImportStatementNotClosedError = FileParsingError{errors.New("import statement not closed")}
+)
+
+type FileParsingError struct {
+	error
+}
+
+func (f FileParsingError) Unwrap() error {
+	return f.error
+}
+
+func (f FileParsingError) Is(err error) bool {
+	_, ok := err.(FileParsingError)
+	return ok
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/newline.go b/vendor/github.com/daixiang0/gci/pkg/section/newline.go
new file mode 100644
index 000000000..4bff91b9d
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/newline.go
@@ -0,0 +1,22 @@
+package section
+
+import (
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/specificity"
+)
+
+const newLineName = "newline"
+
+type NewLine struct{}
+
+func (n NewLine) MatchSpecificity(spec *parse.GciImports) specificity.MatchSpecificity {
+	return specificity.MisMatch{}
+}
+
+func (n NewLine) String() string {
+	return newLineName
+}
+
+func (n NewLine) Type() string {
+	return newLineName
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/parser.go b/vendor/github.com/daixiang0/gci/pkg/section/parser.go
new file mode 100644
index 000000000..9834dcd13
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/parser.go
@@ -0,0 +1,44 @@
+package section
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+func Parse(data []string) (SectionList, error) {
+	if len(data) == 0 {
+		return nil, nil
+	}
+
+	var list SectionList
+	var errString string
+	for _, d := range data {
+		s := strings.ToLower(d)
+		if len(s) == 0 {
+			return nil, nil
+		}
+
+		if s == "default" {
+			list = append(list, Default{})
+		} else if s == "standard" {
+			list = append(list, Standard{})
+		} else if s == "newline" {
+			list = append(list, NewLine{})
+		} else if strings.HasPrefix(s, "prefix(") && len(d) > 8 {
+			list = append(list, Custom{d[7 : len(d)-1]})
+		} else if strings.HasPrefix(s, "commentline(") && len(d) > 13 {
+			list = append(list, Custom{d[12 : len(d)-1]})
+		} else if s == "dot" {
+			list = append(list, Dot{})
+		} else if s == "blank" {
+			list = append(list, Blank{})
+		} else {
+			errString += fmt.Sprintf(" %s", s)
+		}
+	}
+	if errString != "" {
+		return nil, errors.New(fmt.Sprintf("invalid params:%s", errString))
+	}
+	return list, nil
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/prefix.go b/vendor/github.com/daixiang0/gci/pkg/section/prefix.go
new file mode 100644
index 000000000..92ef96377
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/prefix.go
@@ -0,0 +1,30 @@
+package section
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/specificity"
+)
+
+type Custom struct {
+	Prefix string
+}
+
+const CustomType = "custom"
+
+func (c Custom) MatchSpecificity(spec *parse.GciImports) specificity.MatchSpecificity {
+	if strings.HasPrefix(spec.Path, c.Prefix) {
+		return specificity.Match{Length: len(c.Prefix)}
+	}
+	return specificity.MisMatch{}
+}
+
+func (c Custom) String() string {
+	return fmt.Sprintf("prefix(%s)", c.Prefix)
+}
+
+func (c Custom) Type() string {
+	return CustomType
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/section.go b/vendor/github.com/daixiang0/gci/pkg/section/section.go
new file mode 100644
index 000000000..cc0a43f2f
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/section.go
@@ -0,0 +1,36 @@
+package section
+
+import (
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/specificity"
+)
+
+// Section defines a part of the formatted output.
+type Section interface {
+	// MatchSpecificity returns how well an Import matches to this Section
+	MatchSpecificity(spec *parse.GciImports) specificity.MatchSpecificity
+
+	// String Implements the stringer interface
+	String() string
+
+	// return section type
+	Type() string
+}
+
+type SectionList []Section
+
+func (list SectionList) String() []string {
+	var output []string
+	for _, section := range list {
+		output = append(output, section.String())
+	}
+	return output
+}
+
+func DefaultSections() SectionList {
+	return SectionList{Standard{}, Default{}}
+}
+
+func DefaultSectionSeparators() SectionList {
+	return SectionList{NewLine{}}
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/section/standard.go b/vendor/github.com/daixiang0/gci/pkg/section/standard.go
new file mode 100644
index 000000000..26c7e9dc7
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/section/standard.go
@@ -0,0 +1,30 @@
+package section
+
+import (
+	"github.com/daixiang0/gci/pkg/parse"
+	"github.com/daixiang0/gci/pkg/specificity"
+)
+
+const StandardType = "standard"
+
+type Standard struct{}
+
+func (s Standard) MatchSpecificity(spec *parse.GciImports) specificity.MatchSpecificity {
+	if isStandard(spec.Path) {
+		return specificity.StandardMatch{}
+	}
+	return specificity.MisMatch{}
+}
+
+func (s Standard) String() string {
+	return StandardType
+}
+
+func (s Standard) Type() string {
+	return StandardType
+}
+
+func isStandard(pkg string) bool {
+	_, ok := standardPackages[pkg]
+	return ok
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/gci/std.go b/vendor/github.com/daixiang0/gci/pkg/section/standard_list.go
index ac96b55ab..b5d884d37 100644
--- a/vendor/github.com/daixiang0/gci/pkg/gci/std.go
+++ b/vendor/github.com/daixiang0/gci/pkg/section/standard_list.go
@@ -1,6 +1,6 @@
-package gci
+package section
 
-// Code generated based on go1.16beta1. DO NOT EDIT.
+// Code generated based on go1.18.4. DO NOT EDIT.
 
 var standardPackages = map[string]struct{}{
 	"archive/tar":          {},
@@ -38,6 +38,7 @@ var standardPackages = map[string]struct{}{
 	"crypto/x509/pkix":     {},
 	"database/sql":         {},
 	"database/sql/driver":  {},
+	"debug/buildinfo":      {},
 	"debug/dwarf":          {},
 	"debug/elf":            {},
 	"debug/gosym":          {},
@@ -63,6 +64,7 @@ var standardPackages = map[string]struct{}{
 	"fmt":                  {},
 	"go/ast":               {},
 	"go/build":             {},
+	"go/build/constraint":  {},
 	"go/constant":          {},
 	"go/doc":               {},
 	"go/format":            {},
@@ -111,6 +113,7 @@ var standardPackages = map[string]struct{}{
 	"net/http/httputil":    {},
 	"net/http/pprof":       {},
 	"net/mail":             {},
+	"net/netip":            {},
 	"net/rpc":              {},
 	"net/rpc/jsonrpc":      {},
 	"net/smtp":             {},
@@ -154,8 +157,3 @@ var standardPackages = map[string]struct{}{
 	"unicode/utf8":         {},
 	"unsafe":               {},
 }
-
-func isStandardPackage(pkg string) bool {
-	_, ok := standardPackages[pkg]
-	return ok
-}
diff --git a/vendor/github.com/daixiang0/gci/pkg/specificity/default.go b/vendor/github.com/daixiang0/gci/pkg/specificity/default.go
new file mode 100644
index 000000000..f7ae4b87b
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/specificity/default.go
@@ -0,0 +1,19 @@
+package specificity
+
+type Default struct{}
+
+func (d Default) IsMoreSpecific(than MatchSpecificity) bool {
+	return isMoreSpecific(d, than)
+}
+
+func (d Default) Equal(to MatchSpecificity) bool {
+	return equalSpecificity(d, to)
+}
+
+func (d Default) class() specificityClass {
+	return DefaultClass
+}
+
+func (d Default) String() string {
+	return "Default"
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/specificity/match.go b/vendor/github.com/daixiang0/gci/pkg/specificity/match.go
new file mode 100644
index 000000000..f08d2b66b
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/specificity/match.go
@@ -0,0 +1,24 @@
+package specificity
+
+import "fmt"
+
+type Match struct {
+	Length int
+}
+
+func (m Match) IsMoreSpecific(than MatchSpecificity) bool {
+	otherMatch, isMatch := than.(Match)
+	return isMoreSpecific(m, than) || (isMatch && m.Length > otherMatch.Length)
+}
+
+func (m Match) Equal(to MatchSpecificity) bool {
+	return equalSpecificity(m, to)
+}
+
+func (m Match) class() specificityClass {
+	return MatchClass
+}
+
+func (m Match) String() string {
+	return fmt.Sprintf("Match(length: %d)", m.Length)
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/specificity/mismatch.go b/vendor/github.com/daixiang0/gci/pkg/specificity/mismatch.go
new file mode 100644
index 000000000..8e8711146
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/specificity/mismatch.go
@@ -0,0 +1,19 @@
+package specificity
+
+type MisMatch struct{}
+
+func (m MisMatch) IsMoreSpecific(than MatchSpecificity) bool {
+	return isMoreSpecific(m, than)
+}
+
+func (m MisMatch) Equal(to MatchSpecificity) bool {
+	return equalSpecificity(m, to)
+}
+
+func (m MisMatch) class() specificityClass {
+	return MisMatchClass
+}
+
+func (m MisMatch) String() string {
+	return "Mismatch"
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/specificity/name.go b/vendor/github.com/daixiang0/gci/pkg/specificity/name.go
new file mode 100644
index 000000000..1900a0ac5
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/specificity/name.go
@@ -0,0 +1,19 @@
+package specificity
+
+type NameMatch struct{}
+
+func (n NameMatch) IsMoreSpecific(than MatchSpecificity) bool {
+	return isMoreSpecific(n, than)
+}
+
+func (n NameMatch) Equal(to MatchSpecificity) bool {
+	return equalSpecificity(n, to)
+}
+
+func (n NameMatch) class() specificityClass {
+	return NameClass
+}
+
+func (n NameMatch) String() string {
+	return "Name"
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/specificity/specificity.go b/vendor/github.com/daixiang0/gci/pkg/specificity/specificity.go
new file mode 100644
index 000000000..842da1857
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/specificity/specificity.go
@@ -0,0 +1,27 @@
+package specificity
+
+type specificityClass int
+
+const (
+	MisMatchClass = 0
+	DefaultClass  = 10
+	StandardClass = 20
+	MatchClass    = 30
+	NameClass     = 40
+)
+
+// MatchSpecificity is used to determine which section matches an import best
+type MatchSpecificity interface {
+	IsMoreSpecific(than MatchSpecificity) bool
+	Equal(to MatchSpecificity) bool
+	class() specificityClass
+}
+
+func isMoreSpecific(this, than MatchSpecificity) bool {
+	return this.class() > than.class()
+}
+
+func equalSpecificity(base, to MatchSpecificity) bool {
+	// m.class() == to.class() would not work for Match
+	return !base.IsMoreSpecific(to) && !to.IsMoreSpecific(base)
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/specificity/standard.go b/vendor/github.com/daixiang0/gci/pkg/specificity/standard.go
new file mode 100644
index 000000000..72ccaf7e1
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/specificity/standard.go
@@ -0,0 +1,19 @@
+package specificity
+
+type StandardMatch struct{}
+
+func (s StandardMatch) IsMoreSpecific(than MatchSpecificity) bool {
+	return isMoreSpecific(s, than)
+}
+
+func (s StandardMatch) Equal(to MatchSpecificity) bool {
+	return equalSpecificity(s, to)
+}
+
+func (s StandardMatch) class() specificityClass {
+	return StandardClass
+}
+
+func (s StandardMatch) String() string {
+	return "Standard"
+}
diff --git a/vendor/github.com/daixiang0/gci/pkg/utils/constants.go b/vendor/github.com/daixiang0/gci/pkg/utils/constants.go
new file mode 100644
index 000000000..b1de2ea25
--- /dev/null
+++ b/vendor/github.com/daixiang0/gci/pkg/utils/constants.go
@@ -0,0 +1,11 @@
+package utils
+
+const (
+	Indent    = '\t'
+	Linebreak = '\n'
+
+	SectionSeparator = ":"
+
+	ParameterOpeningBrackets = "("
+	ParameterClosingBrackets = ")"
+)