carapace-generate: improve completers performance

still got unneccessary invocations and repetitive steps

Author: rsteube

cmd/carapace-generate/cmd/completers.go

@@ -12,7 +12,7 @@ import (
 )
 
 var completersCmd = &cobra.Command{
-	Use:   "completers DIR [GOOS]",
+	Use:   "completers DIR target",
 	Short: "",
 	Args:  cobra.ExactArgs(2),
 	RunE: func(cmd *cobra.Command, args []string) error {
@@ -58,6 +58,6 @@ func init() {
 
 	carapace.Gen(completersCmd).PositionalCompletion(
 		carapace.ActionDirectories(),
-		carapace.ActionValues("linux", "darwin", "windows", "force_all"), // TODO others, termux as well?
+		carapace.ActionValues("android", "linux", "darwin", "windows", "force_all"), // TODO others, termux as well?
 	)
 }

cmd/carapace-generate/pkg/completer/completers.go

@@ -1,8 +1,9 @@
 package completer
 
 import (
+	"bufio"
 	"encoding/json"
-	"fmt"
+	"io/fs"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -11,6 +12,7 @@ import (
 
 	"github.com/carapace-sh/carapace"
 	"github.com/carapace-sh/carapace-bin/pkg/completer"
+	"github.com/carapace-sh/carapace-bridge/pkg/choices"
 	"github.com/carapace-sh/carapace/pkg/traverse"
 )
 
@@ -29,103 +31,117 @@ func ReadCompleters(dir, goos string) (completer.CompleterMap, error) {
 		"force_all": {"common", "unix", "linux", "bsd", "darwin", "android", "windows", "freebsd", "netbsd", "openbsd"},
 	}
 
-	completers := make(completer.CompleterMap)
+	completers, err := readCompleters(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	filtered := make(completer.CompleterMap)
 	for _, group := range groups[goos] {
-		groupCompleters, err := readCompleters(dir, group)
-		if err != nil {
-			return nil, err
-		}
-		completers.Merge(groupCompleters)
+		filtered.Merge(completers.Filter(choices.Choice{Group: group}))
 	}
-	return completers, nil
+	return filtered, nil
 }
 
-func readCompleters(dir, group string) (completer.CompleterMap, error) {
-	prefix, err := packagePrefix(dir)
+func readCompleters(dir string) (completer.CompleterMap, error) {
+	abs, err := filepath.Abs(dir)
+	if err != nil {
+		return nil, err
+	}
+
+	prefix, err := packagePrefix(abs)
 	if err != nil {
 		return nil, err
 	}
 
 	completers := make(completer.CompleterMap)
-	if files, err := os.ReadDir(filepath.Join(dir, group)); err == nil {
-		for _, file := range files {
-			if file.IsDir() && strings.HasSuffix(file.Name(), "_completer") {
-				name := strings.TrimSuffix(file.Name(), "_completer")
-				if _, err := os.Stat(filepath.Join(dir, group, file.Name(), "cmd/root.go")); err == nil {
-					description, err := readDescription(dir, group, file.Name())
-					if err != nil {
-						return nil, err
-					}
-					url, err := readUrl(dir, group, file.Name())
-					if err != nil {
-						return nil, err
-					}
-					completers[name] = append(completers[name], completer.Completer{
-						Name:        name,
-						Description: description,
-						Group:       group,
-						Package:     filepath.Join(prefix, group, file.Name(), "cmd"),
-						Url:         url,
-					})
+
+	err = filepath.WalkDir(abs, func(path string, d fs.DirEntry, err error) error {
+		if name, ok := strings.CutSuffix(d.Name(), "_completer"); ok {
+			group := filepath.Base(filepath.Dir(path))
+
+			rootPath := filepath.Join(path, "cmd", "root.go")
+			if _, err := os.Stat(rootPath); err == nil {
+				description, url, err := readRoot(rootPath)
+				if err != nil {
+					return err
 				}
+				completers[name] = append(completers[name], completer.Completer{
+					Name:        name,
+					Description: description,
+					Group:       group,
+					Package:     filepath.Join(prefix, group, d.Name(), "cmd"),
+					Url:         url,
+				})
+
+				return filepath.SkipDir
+			}
 
-				if variants, err := os.ReadDir(filepath.Join(dir, group, file.Name())); err == nil {
-					for _, variant := range variants {
-						if _, err := os.Stat(filepath.Join(dir, group, file.Name(), variant.Name(), "cmd/root.go")); err == nil {
-							// TODO path for variants not correct (description/url)
-							description, err := readDescription(dir, group, file.Name()+"/"+variant.Name()) // TODO just pass the root.go
-							if err != nil {
-								return nil, err
-							}
-							url, err := readUrl(dir, group, file.Name()+"/"+variant.Name())
-							if err != nil {
-								return nil, err
-							}
-							completers[name] = append(completers[name], completer.Completer{
-								Name:        name,
-								Description: description,
-								Group:       group,
-								Package:     filepath.Join(prefix, group, file.Name(), variant.Name(), "cmd"),
-								Url:         url,
-								Variant:     variant.Name(),
-							})
+			if variants, err := os.ReadDir(path); err == nil {
+				for _, variant := range variants {
+					if !variant.IsDir() {
+						continue
+					}
+
+					rootPath = filepath.Join(path, variant.Name(), "cmd", "root.go")
+					if _, err := os.Stat(path); err == nil {
+						// TODO path for variants not correct (description/url)
+						description, url, err := readRoot(rootPath)
+						if err != nil {
+							return err
 						}
+						completers[name] = append(completers[name], completer.Completer{
+							Name:        name,
+							Description: description,
+							Group:       group,
+							Package:     filepath.Join(prefix, group, d.Name(), variant.Name(), "cmd"),
+							Url:         url,
+							Variant:     variant.Name(),
+						})
 					}
 				}
 			}
+
+			return filepath.SkipDir
 		}
+		return nil
+	})
+	if err != nil {
+		return nil, err
 	}
 	return completers, nil
 }
 
-func readDescription(root, goos, completer string) (string, error) {
-	content, err := os.ReadFile(fmt.Sprintf("%v/%v/%v/cmd/root.go", root, goos, completer))
+func readRoot(path string) (string, string, error) {
+	f, err := os.Open(path)
 	if err != nil {
-		return "", err
-	}
-
-	re := regexp.MustCompile("^\tShort: +\"(?P<description>.*)\",$")
-	for _, line := range strings.Split(string(content), "\n") {
-		if re.MatchString(line) {
-			return re.FindStringSubmatch(line)[1], nil
-		}
+		return "", "", err
 	}
-	return "", nil // TODO error?
-}
+	defer f.Close()
 
-func readUrl(root, goos, completer string) (string, error) {
-	content, err := os.ReadFile(fmt.Sprintf("%v/%v/%v/cmd/root.go", root, goos, completer))
-	if err != nil {
-		return "", err
-	}
+	rDescription := regexp.MustCompile("^\tShort: +\"(?P<description>.*)\",$")
+	rUrl := regexp.MustCompile("^\tLong: +\"(?P<url>.*)\",$")
 
-	re := regexp.MustCompile("^\tLong: +\"(?P<url>.*)\",$")
-	for _, line := range strings.Split(string(content), "\n") {
-		if re.MatchString(line) {
-			return re.FindStringSubmatch(line)[1], nil
+	var description, url string
+	scanner := bufio.NewScanner(f)
+	for scanner.Scan() {
+		if description != "" && url != "" {
+			break
+		}
+		if description == "" {
+			if matches := rDescription.FindStringSubmatch(scanner.Text()); matches != nil {
+				description = matches[1]
+				continue
+			}
+		}
+		if url == "" {
+			if matches := rUrl.FindStringSubmatch(scanner.Text()); matches != nil {
+				url = matches[1]
+				continue
+			}
 		}
 	}
-	return "", nil // TODO error?
+	return description, url, nil
 }
 
 func packagePrefix(dir string) (string, error) {