From b2f2446b46bf02821d90ebedadae2bf7ae0e880e Mon Sep 17 00:00:00 2001 From: Taras Madan Date: Mon, 5 Sep 2022 14:27:54 +0200 Subject: 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 --- .../github.com/daixiang0/gci/pkg/config/config.go | 90 +++++ .../github.com/daixiang0/gci/pkg/format/format.go | 46 +++ vendor/github.com/daixiang0/gci/pkg/gci/gci.go | 438 ++++++--------------- vendor/github.com/daixiang0/gci/pkg/gci/std.go | 161 -------- vendor/github.com/daixiang0/gci/pkg/io/file.go | 59 +++ vendor/github.com/daixiang0/gci/pkg/io/search.go | 47 +++ vendor/github.com/daixiang0/gci/pkg/io/stdin.go | 27 ++ vendor/github.com/daixiang0/gci/pkg/log/log.go | 50 +++ vendor/github.com/daixiang0/gci/pkg/parse/parse.go | 139 +++++++ .../github.com/daixiang0/gci/pkg/section/blank.go | 25 ++ .../daixiang0/gci/pkg/section/commentline.go | 24 ++ .../daixiang0/gci/pkg/section/default.go | 22 ++ vendor/github.com/daixiang0/gci/pkg/section/dot.go | 25 ++ .../github.com/daixiang0/gci/pkg/section/errors.go | 107 +++++ .../daixiang0/gci/pkg/section/newline.go | 22 ++ .../github.com/daixiang0/gci/pkg/section/parser.go | 44 +++ .../github.com/daixiang0/gci/pkg/section/prefix.go | 30 ++ .../daixiang0/gci/pkg/section/section.go | 36 ++ .../daixiang0/gci/pkg/section/standard.go | 30 ++ .../daixiang0/gci/pkg/section/standard_list.go | 159 ++++++++ .../daixiang0/gci/pkg/specificity/default.go | 19 + .../daixiang0/gci/pkg/specificity/match.go | 24 ++ .../daixiang0/gci/pkg/specificity/mismatch.go | 19 + .../daixiang0/gci/pkg/specificity/name.go | 19 + .../daixiang0/gci/pkg/specificity/specificity.go | 27 ++ .../daixiang0/gci/pkg/specificity/standard.go | 19 + .../daixiang0/gci/pkg/utils/constants.go | 11 + 27 files changed, 1250 insertions(+), 469 deletions(-) create mode 100644 vendor/github.com/daixiang0/gci/pkg/config/config.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/format/format.go delete mode 100644 vendor/github.com/daixiang0/gci/pkg/gci/std.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/io/file.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/io/search.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/io/stdin.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/log/log.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/parse/parse.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/blank.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/commentline.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/default.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/dot.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/errors.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/newline.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/parser.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/prefix.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/section.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/standard.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/section/standard_list.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/specificity/default.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/specificity/match.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/specificity/mismatch.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/specificity/name.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/specificity/specificity.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/specificity/standard.go create mode 100644 vendor/github.com/daixiang0/gci/pkg/utils/constants.go (limited to 'vendor/github.com/daixiang0') 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/gci/std.go b/vendor/github.com/daixiang0/gci/pkg/gci/std.go deleted file mode 100644 index ac96b55ab..000000000 --- a/vendor/github.com/daixiang0/gci/pkg/gci/std.go +++ /dev/null @@ -1,161 +0,0 @@ -package gci - -// Code generated based on go1.16beta1. DO NOT EDIT. - -var standardPackages = map[string]struct{}{ - "archive/tar": {}, - "archive/zip": {}, - "bufio": {}, - "bytes": {}, - "compress/bzip2": {}, - "compress/flate": {}, - "compress/gzip": {}, - "compress/lzw": {}, - "compress/zlib": {}, - "container/heap": {}, - "container/list": {}, - "container/ring": {}, - "context": {}, - "crypto": {}, - "crypto/aes": {}, - "crypto/cipher": {}, - "crypto/des": {}, - "crypto/dsa": {}, - "crypto/ecdsa": {}, - "crypto/ed25519": {}, - "crypto/elliptic": {}, - "crypto/hmac": {}, - "crypto/md5": {}, - "crypto/rand": {}, - "crypto/rc4": {}, - "crypto/rsa": {}, - "crypto/sha1": {}, - "crypto/sha256": {}, - "crypto/sha512": {}, - "crypto/subtle": {}, - "crypto/tls": {}, - "crypto/x509": {}, - "crypto/x509/pkix": {}, - "database/sql": {}, - "database/sql/driver": {}, - "debug/dwarf": {}, - "debug/elf": {}, - "debug/gosym": {}, - "debug/macho": {}, - "debug/pe": {}, - "debug/plan9obj": {}, - "embed": {}, - "encoding": {}, - "encoding/ascii85": {}, - "encoding/asn1": {}, - "encoding/base32": {}, - "encoding/base64": {}, - "encoding/binary": {}, - "encoding/csv": {}, - "encoding/gob": {}, - "encoding/hex": {}, - "encoding/json": {}, - "encoding/pem": {}, - "encoding/xml": {}, - "errors": {}, - "expvar": {}, - "flag": {}, - "fmt": {}, - "go/ast": {}, - "go/build": {}, - "go/constant": {}, - "go/doc": {}, - "go/format": {}, - "go/importer": {}, - "go/parser": {}, - "go/printer": {}, - "go/scanner": {}, - "go/token": {}, - "go/types": {}, - "hash": {}, - "hash/adler32": {}, - "hash/crc32": {}, - "hash/crc64": {}, - "hash/fnv": {}, - "hash/maphash": {}, - "html": {}, - "html/template": {}, - "image": {}, - "image/color": {}, - "image/color/palette": {}, - "image/draw": {}, - "image/gif": {}, - "image/jpeg": {}, - "image/png": {}, - "index/suffixarray": {}, - "io": {}, - "io/fs": {}, - "io/ioutil": {}, - "log": {}, - "log/syslog": {}, - "math": {}, - "math/big": {}, - "math/bits": {}, - "math/cmplx": {}, - "math/rand": {}, - "mime": {}, - "mime/multipart": {}, - "mime/quotedprintable": {}, - "net": {}, - "net/http": {}, - "net/http/cgi": {}, - "net/http/cookiejar": {}, - "net/http/fcgi": {}, - "net/http/httptest": {}, - "net/http/httptrace": {}, - "net/http/httputil": {}, - "net/http/pprof": {}, - "net/mail": {}, - "net/rpc": {}, - "net/rpc/jsonrpc": {}, - "net/smtp": {}, - "net/textproto": {}, - "net/url": {}, - "os": {}, - "os/exec": {}, - "os/signal": {}, - "os/user": {}, - "path": {}, - "path/filepath": {}, - "plugin": {}, - "reflect": {}, - "regexp": {}, - "regexp/syntax": {}, - "runtime": {}, - "runtime/cgo": {}, - "runtime/debug": {}, - "runtime/metrics": {}, - "runtime/pprof": {}, - "runtime/race": {}, - "runtime/trace": {}, - "sort": {}, - "strconv": {}, - "strings": {}, - "sync": {}, - "sync/atomic": {}, - "syscall": {}, - "testing": {}, - "testing/fstest": {}, - "testing/iotest": {}, - "testing/quick": {}, - "text/scanner": {}, - "text/tabwriter": {}, - "text/template": {}, - "text/template/parse": {}, - "time": {}, - "time/tzdata": {}, - "unicode": {}, - "unicode/utf16": {}, - "unicode/utf8": {}, - "unsafe": {}, -} - -func isStandardPackage(pkg string) bool { - _, ok := standardPackages[pkg] - return ok -} 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/section/standard_list.go b/vendor/github.com/daixiang0/gci/pkg/section/standard_list.go new file mode 100644 index 000000000..b5d884d37 --- /dev/null +++ b/vendor/github.com/daixiang0/gci/pkg/section/standard_list.go @@ -0,0 +1,159 @@ +package section + +// Code generated based on go1.18.4. DO NOT EDIT. + +var standardPackages = map[string]struct{}{ + "archive/tar": {}, + "archive/zip": {}, + "bufio": {}, + "bytes": {}, + "compress/bzip2": {}, + "compress/flate": {}, + "compress/gzip": {}, + "compress/lzw": {}, + "compress/zlib": {}, + "container/heap": {}, + "container/list": {}, + "container/ring": {}, + "context": {}, + "crypto": {}, + "crypto/aes": {}, + "crypto/cipher": {}, + "crypto/des": {}, + "crypto/dsa": {}, + "crypto/ecdsa": {}, + "crypto/ed25519": {}, + "crypto/elliptic": {}, + "crypto/hmac": {}, + "crypto/md5": {}, + "crypto/rand": {}, + "crypto/rc4": {}, + "crypto/rsa": {}, + "crypto/sha1": {}, + "crypto/sha256": {}, + "crypto/sha512": {}, + "crypto/subtle": {}, + "crypto/tls": {}, + "crypto/x509": {}, + "crypto/x509/pkix": {}, + "database/sql": {}, + "database/sql/driver": {}, + "debug/buildinfo": {}, + "debug/dwarf": {}, + "debug/elf": {}, + "debug/gosym": {}, + "debug/macho": {}, + "debug/pe": {}, + "debug/plan9obj": {}, + "embed": {}, + "encoding": {}, + "encoding/ascii85": {}, + "encoding/asn1": {}, + "encoding/base32": {}, + "encoding/base64": {}, + "encoding/binary": {}, + "encoding/csv": {}, + "encoding/gob": {}, + "encoding/hex": {}, + "encoding/json": {}, + "encoding/pem": {}, + "encoding/xml": {}, + "errors": {}, + "expvar": {}, + "flag": {}, + "fmt": {}, + "go/ast": {}, + "go/build": {}, + "go/build/constraint": {}, + "go/constant": {}, + "go/doc": {}, + "go/format": {}, + "go/importer": {}, + "go/parser": {}, + "go/printer": {}, + "go/scanner": {}, + "go/token": {}, + "go/types": {}, + "hash": {}, + "hash/adler32": {}, + "hash/crc32": {}, + "hash/crc64": {}, + "hash/fnv": {}, + "hash/maphash": {}, + "html": {}, + "html/template": {}, + "image": {}, + "image/color": {}, + "image/color/palette": {}, + "image/draw": {}, + "image/gif": {}, + "image/jpeg": {}, + "image/png": {}, + "index/suffixarray": {}, + "io": {}, + "io/fs": {}, + "io/ioutil": {}, + "log": {}, + "log/syslog": {}, + "math": {}, + "math/big": {}, + "math/bits": {}, + "math/cmplx": {}, + "math/rand": {}, + "mime": {}, + "mime/multipart": {}, + "mime/quotedprintable": {}, + "net": {}, + "net/http": {}, + "net/http/cgi": {}, + "net/http/cookiejar": {}, + "net/http/fcgi": {}, + "net/http/httptest": {}, + "net/http/httptrace": {}, + "net/http/httputil": {}, + "net/http/pprof": {}, + "net/mail": {}, + "net/netip": {}, + "net/rpc": {}, + "net/rpc/jsonrpc": {}, + "net/smtp": {}, + "net/textproto": {}, + "net/url": {}, + "os": {}, + "os/exec": {}, + "os/signal": {}, + "os/user": {}, + "path": {}, + "path/filepath": {}, + "plugin": {}, + "reflect": {}, + "regexp": {}, + "regexp/syntax": {}, + "runtime": {}, + "runtime/cgo": {}, + "runtime/debug": {}, + "runtime/metrics": {}, + "runtime/pprof": {}, + "runtime/race": {}, + "runtime/trace": {}, + "sort": {}, + "strconv": {}, + "strings": {}, + "sync": {}, + "sync/atomic": {}, + "syscall": {}, + "testing": {}, + "testing/fstest": {}, + "testing/iotest": {}, + "testing/quick": {}, + "text/scanner": {}, + "text/tabwriter": {}, + "text/template": {}, + "text/template/parse": {}, + "time": {}, + "time/tzdata": {}, + "unicode": {}, + "unicode/utf16": {}, + "unicode/utf8": {}, + "unsafe": {}, +} 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 = ")" +) -- cgit mrf-deployment