Add command-specific argument completions

Complete bug IDs, bridges, users, labels where appropriate.

This works in bash and fish. ZSH is not yet supported by Cobra.
In fish, descriptions (the part of a completion after the "\t") are shown
as completion label, and can be searched with Ctrl+S.

Reproduce with

	fish -C 'source misc/fish_completion/git-bug'
	git bug select ^I

(tested with fish version 3.3.1)

Also works with bash, but only for "git-bug" (with the dash)

	bash --rcfile <(echo source misc/bash_completion/git-bug)
	git-bug select ^I

Closes #493

1 files changed, 350 insertions, 0 deletions

diff --git a/commands/helper_completion.go b/commands/helper_completion.go
new file mode 100644
index 00000000..a23e810f
--- /dev/null
+++ b/commands/helper_completion.go
@@ -0,0 +1,350 @@
+package commands
+
+import (
+	"sort"
+	"strings"
+
+	"github.com/spf13/cobra"
+
+	"github.com/MichaelMure/git-bug/bridge"
+	"github.com/MichaelMure/git-bug/bridge/core/auth"
+	"github.com/MichaelMure/git-bug/bug"
+	"github.com/MichaelMure/git-bug/cache"
+	_select "github.com/MichaelMure/git-bug/commands/select"
+)
+
+type validArgsFunction func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective)
+
+func completionHandlerError(err error) (completions []string, directives cobra.ShellCompDirective) {
+	return nil, cobra.ShellCompDirectiveError
+}
+
+func completeBridge(env *Env) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		if err := loadBackend(env)(cmd, args); err != nil {
+			return completionHandlerError(err)
+		}
+		defer func() {
+			_ = env.backend.Close()
+		}()
+
+		bridges, err := bridge.ConfiguredBridges(env.backend)
+		if err != nil {
+			return completionHandlerError(err)
+		}
+
+		completions = make([]string, len(bridges))
+		for i, bridge := range bridges {
+			completions[i] = bridge + "\t" + "Bridge"
+		}
+
+		return completions, cobra.ShellCompDirectiveDefault
+	}
+}
+
+func completeBridgeAuth(env *Env) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		if err := loadBackend(env)(cmd, args); err != nil {
+			return completionHandlerError(err)
+		}
+		defer func() {
+			_ = env.backend.Close()
+		}()
+
+		creds, err := auth.List(env.backend)
+		if err != nil {
+			return completionHandlerError(err)
+		}
+
+		completions = make([]string, len(creds))
+		for i, cred := range creds {
+			meta := make([]string, 0, len(cred.Metadata()))
+			for k, v := range cred.Metadata() {
+				meta = append(meta, k+":"+v)
+			}
+			sort.Strings(meta)
+			metaFmt := strings.Join(meta, ",")
+
+			completions[i] = cred.ID().Human() + "\t" + cred.Target() + " " + string(cred.Kind()) + " " + metaFmt
+		}
+
+		return completions, cobra.ShellCompDirectiveDefault
+	}
+}
+
+func completeBug(env *Env) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		if err := loadBackend(env)(cmd, args); err != nil {
+			return completionHandlerError(err)
+		}
+		defer func() {
+			_ = env.backend.Close()
+		}()
+
+		allIds := env.backend.AllBugsIds()
+		bugExcerpt := make([]*cache.BugExcerpt, len(allIds))
+		for i, id := range allIds {
+			var err error
+			bugExcerpt[i], err = env.backend.ResolveBugExcerpt(id)
+			if err != nil {
+				return completionHandlerError(err)
+			}
+		}
+
+		completions = make([]string, len(allIds))
+		for i, id := range allIds {
+			completions[i] = id.Human() + "\t" + bugExcerpt[i].Title
+		}
+		return completions, cobra.ShellCompDirectiveDefault
+	}
+}
+
+func completeBugAndLabels(env *Env, addOrRemove bool) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective) {
+		if len(args) == 0 {
+			return completeBug(env)(cmd, args, toComplete)
+		}
+
+		if err := loadBackend(env)(cmd, args); err != nil {
+			return completionHandlerError(err)
+		}
+		defer func() {
+			_ = env.backend.Close()
+		}()
+
+		b, args, err := _select.ResolveBug(env.backend, args)
+		if err != nil {
+			return completionHandlerError(err)
+		}
+
+		snap := b.Snapshot()
+
+		seenLabels := map[bug.Label]bool{}
+		for _, label := range args {
+			seenLabels[bug.Label(label)] = addOrRemove
+		}
+
+		var labels []bug.Label
+		if addOrRemove {
+			for _, label := range snap.Labels {
+				seenLabels[label] = true
+			}
+
+			allLabels := env.backend.ValidLabels()
+			labels = make([]bug.Label, 0, len(allLabels))
+			for _, label := range allLabels {
+				if !seenLabels[label] {
+					labels = append(labels, label)
+				}
+			}
+		} else {
+			labels = make([]bug.Label, 0, len(snap.Labels))
+			for _, label := range snap.Labels {
+				if seenLabels[label] {
+					labels = append(labels, label)
+				}
+			}
+		}
+
+		completions = make([]string, len(labels))
+		for i, label := range labels {
+			completions[i] = string(label) + "\t" + "Label"
+		}
+
+		return completions, cobra.ShellCompDirectiveDefault
+	}
+}
+
+func completeFrom(choices []string) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+		return choices, cobra.ShellCompDirectiveDefault
+	}
+}
+
+func completeGitRemote(env *Env) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		if err := loadBackend(env)(cmd, args); err != nil {
+			return completionHandlerError(err)
+		}
+		defer func() {
+			_ = env.backend.Close()
+		}()
+
+		remoteMap, err := env.backend.GetRemotes()
+		if err != nil {
+			return completionHandlerError(err)
+		}
+		completions = make([]string, 0, len(remoteMap))
+		for remote, url := range remoteMap {
+			completions = append(completions, remote+"\t"+"Remote: "+url)
+		}
+		sort.Strings(completions)
+		return completions, cobra.ShellCompDirectiveDefault
+	}
+}
+
+func completeLabel(env *Env) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+		if err := loadBackend(env)(cmd, args); err != nil {
+			return completionHandlerError(err)
+		}
+		defer func() {
+			_ = env.backend.Close()
+		}()
+
+		labels := env.backend.ValidLabels()
+		completions = make([]string, len(labels))
+		for i, label := range labels {
+			completions[i] = string(label) + "\t" + "Label"
+		}
+		return completions, cobra.ShellCompDirectiveDefault
+	}
+}
+
+func completeLs(env *Env) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective) {
+		if strings.HasPrefix(toComplete, "status:") {
+			completions = append(completions, "status:open\tOpen bugs")
+			completions = append(completions, "status:closed\tClosed bugs")
+			return completions, cobra.ShellCompDirectiveDefault
+		}
+
+		byPerson := []string{"author:", "participant:", "actor:"}
+		byLabel := []string{"label:", "no:"}
+		needBackend := false
+		for _, key := range append(byPerson, byLabel...) {
+			if strings.HasPrefix(toComplete, key) {
+				needBackend = true
+			}
+		}
+
+		if needBackend {
+			if err := loadBackend(env)(cmd, args); err != nil {
+				return completionHandlerError(err)
+			}
+			defer func() {
+				_ = env.backend.Close()
+			}()
+		}
+
+		for _, key := range byPerson {
+			if !strings.HasPrefix(toComplete, key) {
+				continue
+			}
+			ids := env.backend.AllIdentityIds()
+			completions = make([]string, len(ids))
+			for i, id := range ids {
+				user, err := env.backend.ResolveIdentityExcerpt(id)
+				if err != nil {
+					return completionHandlerError(err)
+				}
+				var handle string
+				if user.Login != "" {
+					handle = user.Login
+				} else {
+					// "author:John Doe" does not work yet, so use the first name.
+					handle = strings.Split(user.Name, " ")[0]
+				}
+				completions[i] = key + handle + "\t" + user.DisplayName()
+			}
+			return completions, cobra.ShellCompDirectiveDefault
+		}
+
+		for _, key := range byLabel {
+			if !strings.HasPrefix(toComplete, key) {
+				continue
+			}
+			labels := env.backend.ValidLabels()
+			completions = make([]string, len(labels))
+			for i, label := range labels {
+				completions[i] = key + string(label)
+			}
+			return completions, cobra.ShellCompDirectiveDefault
+		}
+
+		completions = []string{
+			"actor:\tFilter by actor",
+			"author:\tFilter by author",
+			"label:\tFilter by label",
+			"no:\tExclude bugs by label",
+			"participant:\tFilter by participant",
+			"status:\tFilter by open/close status",
+			"title:\tFilter by title",
+		}
+		return completions, cobra.ShellCompDirectiveNoSpace
+	}
+}
+
+func completeUser(env *Env) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		if err := loadBackend(env)(cmd, args); err != nil {
+			return completionHandlerError(err)
+		}
+		defer func() {
+			_ = env.backend.Close()
+		}()
+
+		ids := env.backend.AllIdentityIds()
+		completions = make([]string, len(ids))
+		for i, id := range ids {
+			user, err := env.backend.ResolveIdentityExcerpt(id)
+			if err != nil {
+				return completionHandlerError(err)
+			}
+			completions[i] = user.Id.Human() + "\t" + user.DisplayName()
+		}
+		return completions, cobra.ShellCompDirectiveDefault
+	}
+}
+
+func completeUserForQuery(env *Env) validArgsFunction {
+	return func(cmd *cobra.Command, args []string, toComplete string) (completions []string, directives cobra.ShellCompDirective) {
+		if len(args) > 0 {
+			return nil, cobra.ShellCompDirectiveNoFileComp
+		}
+
+		if err := loadBackend(env)(cmd, args); err != nil {
+			return completionHandlerError(err)
+		}
+		defer func() {
+			_ = env.backend.Close()
+		}()
+
+		ids := env.backend.AllIdentityIds()
+		completions = make([]string, len(ids))
+		for i, id := range ids {
+			user, err := env.backend.ResolveIdentityExcerpt(id)
+			if err != nil {
+				return completionHandlerError(err)
+			}
+			var handle string
+			if user.Login != "" {
+				handle = user.Login
+			} else {
+				// "author:John Doe" does not work yet, so use the first name.
+				handle = strings.Split(user.Name, " ")[0]
+			}
+			completions[i] = handle + "\t" + user.DisplayName()
+		}
+		return completions, cobra.ShellCompDirectiveDefault
+	}
+}