From f60cfd1e40319e9a740d64e6650c88d8adf0c686 Mon Sep 17 00:00:00 2001 From: Grzegorz Dlugoszewski Date: Sun, 24 Aug 2025 15:44:22 +0200 Subject: [PATCH] Fix issues found by varnamelen linter --- .golangci.yml | 7 ++++++- pkg/get.go | 28 ++++++++++++++-------------- pkg/git/finder.go | 18 +++++++++--------- pkg/git/repo.go | 6 +++--- pkg/list.go | 10 +++++----- pkg/print/flat.go | 18 +++++++++--------- pkg/print/tree.go | 32 ++++++++++++++++---------------- 7 files changed, 62 insertions(+), 57 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index b2b5a08..e2a2967 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -22,5 +22,10 @@ linters: rules: - path: _test.go linters: - - dupl # We don't mind duplicated code in tests. It helps with clarity + - dupl # We don't mind duplicated code in tests. It helps with clarity + - varnamelen # We don't mind short var names in tests. + - path: test/ + linters: + - dupl + - varnamelen diff --git a/pkg/get.go b/pkg/get.go index 754c73b..e59f90b 100644 --- a/pkg/get.go +++ b/pkg/get.go @@ -18,32 +18,32 @@ type GetCfg struct { } // Get executes the "git get" command. -func Get(c *GetCfg) error { - if c.URL == "" && c.Dump == "" { +func Get(conf *GetCfg) error { + if conf.URL == "" && conf.Dump == "" { return fmt.Errorf("missing argument or --dump flag") } - if c.URL != "" { - return cloneSingleRepo(c) + if conf.URL != "" { + return cloneSingleRepo(conf) } - if c.Dump != "" { - return cloneDumpFile(c) + if conf.Dump != "" { + return cloneDumpFile(conf) } return nil } -func cloneSingleRepo(c *GetCfg) error { - url, err := ParseURL(c.URL, c.DefHost, c.DefScheme) +func cloneSingleRepo(conf *GetCfg) error { + url, err := ParseURL(conf.URL, conf.DefHost, conf.DefScheme) if err != nil { return err } opts := &git.CloneOpts{ URL: url, - Path: filepath.Join(c.Root, URLToPath(*url, c.SkipHost)), - Branch: c.Branch, + Path: filepath.Join(conf.Root, URLToPath(*url, conf.SkipHost)), + Branch: conf.Branch, } _, err = git.Clone(opts) @@ -51,21 +51,21 @@ func cloneSingleRepo(c *GetCfg) error { return err } -func cloneDumpFile(c *GetCfg) error { - parsedLines, err := parseDumpFile(c.Dump) +func cloneDumpFile(conf *GetCfg) error { + parsedLines, err := parseDumpFile(conf.Dump) if err != nil { return err } for _, line := range parsedLines { - url, err := ParseURL(line.rawurl, c.DefHost, c.DefScheme) + url, err := ParseURL(line.rawurl, conf.DefHost, conf.DefScheme) if err != nil { return err } opts := &git.CloneOpts{ URL: url, - Path: filepath.Join(c.Root, URLToPath(*url, c.SkipHost)), + Path: filepath.Join(conf.Root, URLToPath(*url, conf.SkipHost)), Branch: line.branch, } diff --git a/pkg/git/finder.go b/pkg/git/finder.go index 5ccd96d..374aea0 100644 --- a/pkg/git/finder.go +++ b/pkg/git/finder.go @@ -53,7 +53,7 @@ func (f *RepoFinder) Find() error { return fmt.Errorf("failed to access root path: %w", err) } - err := filepath.WalkDir(f.root, func(path string, d fs.DirEntry, err error) error { + err := filepath.WalkDir(f.root, func(path string, dir fs.DirEntry, err error) error { // Handle walk errors if err != nil { // Skip permission errors but continue walking @@ -65,12 +65,12 @@ func (f *RepoFinder) Find() error { } // Only process directories - if !d.IsDir() { + if !dir.IsDir() { return nil } // Case 1: We're looking at a .git directory itself - if d.Name() == dotgit { + if dir.Name() == dotgit { parentPath := filepath.Dir(path) f.addIfOk(parentPath) @@ -101,7 +101,7 @@ func (f *RepoFinder) Find() error { // If fetch equals true, it first fetches from the remote repo before loading the status. // Each repo is loaded concurrently by a separate worker, with max 100 workers being active at the same time. func (f *RepoFinder) LoadAll(fetch bool) []*Status { - var ss []*Status + var statuses []*Status reposChan := make(chan *Repo, f.maxWorkers) statusChan := make(chan *Status, f.maxWorkers) @@ -118,18 +118,18 @@ func (f *RepoFinder) LoadAll(fetch bool) []*Status { // Read statuses from the statusChan and add then to the result slice. // Close the channel when all repos are loaded. for status := range statusChan { - ss = append(ss, status) - if len(ss) == len(f.repos) { + statuses = append(statuses, status) + if len(statuses) == len(f.repos) { close(statusChan) } } // Sort the status slice by path - sort.Slice(ss, func(i, j int) bool { - return strings.Compare(ss[i].path, ss[j].path) < 0 + sort.Slice(statuses, func(i, j int) bool { + return strings.Compare(statuses[i].path, statuses[j].path) < 0 }) - return ss + return statuses } func loadRepos(repos []*Repo, reposChan chan<- *Repo) { diff --git a/pkg/git/repo.go b/pkg/git/repo.go index 31e86f7..9a11861 100644 --- a/pkg/git/repo.go +++ b/pkg/git/repo.go @@ -170,14 +170,14 @@ func (r *Repo) AheadBehind(branch string, upstream string) (int, int, error) { } // rev-list --left-right --count output is separated by a tab - lr := strings.Split(out, "\t") + count := strings.Split(out, "\t") - ahead, err := strconv.Atoi(lr[0]) + ahead, err := strconv.Atoi(count[0]) if err != nil { return 0, 0, err } - behind, err := strconv.Atoi(lr[1]) + behind, err := strconv.Atoi(count[1]) if err != nil { return 0, 0, err } diff --git a/pkg/list.go b/pkg/list.go index 8b7bd9d..7173b9d 100644 --- a/pkg/list.go +++ b/pkg/list.go @@ -16,24 +16,24 @@ type ListCfg struct { } // List executes the "git list" command. -func List(c *ListCfg) error { - finder := git.NewRepoFinder(c.Root) +func List(conf *ListCfg) error { + finder := git.NewRepoFinder(conf.Root) if err := finder.Find(); err != nil { return err } - statuses := finder.LoadAll(c.Fetch) + statuses := finder.LoadAll(conf.Fetch) printables := make([]print.Printable, len(statuses)) for i := range statuses { printables[i] = statuses[i] } - switch c.Output { + switch conf.Output { case cfg.OutFlat: fmt.Print(print.NewFlatPrinter().Print(printables)) case cfg.OutTree: - fmt.Print(print.NewTreePrinter().Print(c.Root, printables)) + fmt.Print(print.NewTreePrinter().Print(conf.Root, printables)) case cfg.OutDump: fmt.Print(print.NewDumpPrinter().Print(printables)) default: diff --git a/pkg/print/flat.go b/pkg/print/flat.go index 4bafb56..24576bb 100644 --- a/pkg/print/flat.go +++ b/pkg/print/flat.go @@ -18,18 +18,18 @@ func NewFlatPrinter() *FlatPrinter { func (p *FlatPrinter) Print(repos []Printable) string { var str strings.Builder - for _, r := range repos { - str.WriteString(strings.TrimSuffix(r.Path(), string(os.PathSeparator))) + for _, repo := range repos { + str.WriteString(strings.TrimSuffix(repo.Path(), string(os.PathSeparator))) - if len(r.Errors()) > 0 { + if len(repo.Errors()) > 0 { str.WriteString(" " + red("error") + "\n") continue } - str.WriteString(" " + blue(r.Current())) + str.WriteString(" " + blue(repo.Current())) - current := r.BranchStatus(r.Current()) - worktree := r.WorkTreeStatus() + current := repo.BranchStatus(repo.Current()) + worktree := repo.WorkTreeStatus() if worktree != "" { worktree = fmt.Sprintf("[ %s ]", worktree) @@ -41,13 +41,13 @@ func (p *FlatPrinter) Print(repos []Printable) string { str.WriteString(" " + strings.Join([]string{yellow(current), red(worktree)}, " ")) } - for _, branch := range r.Branches() { - status := r.BranchStatus(branch) + for _, branch := range repo.Branches() { + status := repo.BranchStatus(branch) if status == "" { status = green("ok") } - indent := strings.Repeat(" ", len(r.Path())-1) + indent := strings.Repeat(" ", len(repo.Path())-1) str.WriteString(fmt.Sprintf("\n%s %s %s", indent, blue(branch), yellow(status))) } diff --git a/pkg/print/tree.go b/pkg/print/tree.go index 16fd97b..7021673 100644 --- a/pkg/print/tree.go +++ b/pkg/print/tree.go @@ -88,8 +88,8 @@ func (n *Node) GetChild(val string) *Node { func buildTree(root string, repos []Printable) *Node { tree := Root(root) - for _, r := range repos { - path := strings.TrimPrefix(r.Path(), root) + for _, repo := range repos { + path := strings.TrimPrefix(repo.Path(), root) path = strings.Trim(path, string(filepath.Separator)) subs := strings.Split(path, string(filepath.Separator)) @@ -98,14 +98,14 @@ func buildTree(root string, repos []Printable) *Node { // If not, add it to node's children and move to next fragment. // If it does, just move to the next fragment. node := tree - for i, sub := range subs { + for idx, sub := range subs { child := node.GetChild(sub) if child == nil { node = node.Add(sub) // If that's the last fragment, it's a tree leaf and needs a *Repo attached. - if i == len(subs)-1 { - node.repo = r + if idx == len(subs)-1 { + node.repo = repo } continue @@ -120,28 +120,28 @@ func buildTree(root string, repos []Printable) *Node { // printTree renders the repo tree by recursively traversing the tree nodes. // If a node doesn't have any children, it's a leaf node containing the repo status. -func (p *TreePrinter) printTree(node *Node, tp treeprint.Tree) { +func (p *TreePrinter) printTree(node *Node, tree treeprint.Tree) { if node.children == nil { - tp.SetValue(printLeaf(node)) + tree.SetValue(printLeaf(node)) } for _, child := range node.children { - branch := tp.AddBranch(child.val) + branch := tree.AddBranch(child.val) p.printTree(child, branch) } } func printLeaf(node *Node) string { - r := node.repo + repo := node.repo // If any errors happened during status loading, don't print the status but "error" instead. // Actual error messages are printed in bulk below the tree. - if len(r.Errors()) > 0 { + if len(repo.Errors()) > 0 { return fmt.Sprintf("%s %s", node.val, red("error")) } - current := r.BranchStatus(r.Current()) - worktree := r.WorkTreeStatus() + current := repo.BranchStatus(repo.Current()) + worktree := repo.WorkTreeStatus() if worktree != "" { worktree = fmt.Sprintf("[ %s ]", worktree) @@ -150,13 +150,13 @@ func printLeaf(node *Node) string { var str strings.Builder if worktree == "" && current == "" { - str.WriteString(fmt.Sprintf("%s %s %s", node.val, blue(r.Current()), green("ok"))) + str.WriteString(fmt.Sprintf("%s %s %s", node.val, blue(repo.Current()), green("ok"))) } else { - str.WriteString(fmt.Sprintf("%s %s %s", node.val, blue(r.Current()), strings.Join([]string{yellow(current), red(worktree)}, " "))) + str.WriteString(fmt.Sprintf("%s %s %s", node.val, blue(repo.Current()), strings.Join([]string{yellow(current), red(worktree)}, " "))) } - for _, branch := range r.Branches() { - status := r.BranchStatus(branch) + for _, branch := range repo.Branches() { + status := repo.BranchStatus(branch) if status == "" { status = green("ok") }