The approach is lifted from cobra: `tailscale completion bash` emits a bash
script for configuring the shell's autocomplete:
. <( tailscale completion bash )
so that typing:
tailscale st<TAB>
invokes:
tailscale completion __complete -- st
RELNOTE=tailscale CLI now supports shell tab-completion
Fixes #3793
Signed-off-by: Paul Scott <paul@tailscale.com>
main
Paul Scott
2 years ago
committed by
Paul Scott
parent
21a0fe1b9b
commit
82394debb7
@ -0,0 +1,160 @@ |
|||||||
|
// Copyright (c) Tailscale Inc & AUTHORS
|
||||||
|
// SPDX-License-Identifier: BSD-3-Clause
|
||||||
|
|
||||||
|
//go:build go1.19 && !ts_omit_completion
|
||||||
|
|
||||||
|
// Package ffcomplete provides shell tab-completion of subcommands, flags and
|
||||||
|
// arguments for Go programs written with [ffcli].
|
||||||
|
//
|
||||||
|
// The shell integration scripts have been extracted from Cobra
|
||||||
|
// (https://cobra.dev/), whose authors deserve most of the credit for this work.
|
||||||
|
// These shell completion functions invoke `$0 completion __complete -- ...`
|
||||||
|
// which is wired up to [Complete].
|
||||||
|
package ffcomplete |
||||||
|
|
||||||
|
import ( |
||||||
|
"context" |
||||||
|
"flag" |
||||||
|
"fmt" |
||||||
|
"io" |
||||||
|
"log" |
||||||
|
"os" |
||||||
|
"strconv" |
||||||
|
"strings" |
||||||
|
|
||||||
|
"github.com/peterbourgon/ff/v3/ffcli" |
||||||
|
"tailscale.com/cmd/tailscale/cli/ffcomplete/internal" |
||||||
|
"tailscale.com/tempfork/spf13/cobra" |
||||||
|
) |
||||||
|
|
||||||
|
type compOpts struct { |
||||||
|
showFlags bool |
||||||
|
showDescs bool |
||||||
|
} |
||||||
|
|
||||||
|
func newFS(name string, opts *compOpts) *flag.FlagSet { |
||||||
|
fs := flag.NewFlagSet(name, flag.ContinueOnError) |
||||||
|
fs.BoolVar(&opts.showFlags, "flags", true, "Suggest flag completions with subcommands") |
||||||
|
fs.BoolVar(&opts.showDescs, "descs", true, "Include flag, subcommand, and other descriptions in completions") |
||||||
|
return fs |
||||||
|
} |
||||||
|
|
||||||
|
// Inject adds the 'completion' subcommand to the root command which provide the
|
||||||
|
// user with shell scripts for calling `completion __command` to provide
|
||||||
|
// tab-completion suggestions.
|
||||||
|
//
|
||||||
|
// root.Name needs to match the command that the user is tab-completing for the
|
||||||
|
// shell script to work as expected by default.
|
||||||
|
//
|
||||||
|
// The hide function is called with the __complete Command instance to provide a
|
||||||
|
// hook to omit it from the help output, if desired.
|
||||||
|
func Inject(root *ffcli.Command, hide func(*ffcli.Command), usageFunc func(*ffcli.Command) string) { |
||||||
|
var opts compOpts |
||||||
|
compFS := newFS("completion", &opts) |
||||||
|
|
||||||
|
completeCmd := &ffcli.Command{ |
||||||
|
Name: "__complete", |
||||||
|
ShortUsage: root.Name + " completion __complete -- <args to complete...>", |
||||||
|
ShortHelp: "Tab-completion suggestions for interactive shells", |
||||||
|
UsageFunc: usageFunc, |
||||||
|
FlagSet: compFS, |
||||||
|
Exec: func(ctx context.Context, args []string) error { |
||||||
|
// Set up debug logging for the rest of this function call.
|
||||||
|
if t := os.Getenv("BASH_COMP_DEBUG_FILE"); t != "" { |
||||||
|
tf, err := os.OpenFile(t, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o600) |
||||||
|
if err != nil { |
||||||
|
return fmt.Errorf("opening debug file: %w", err) |
||||||
|
} |
||||||
|
defer func(origW io.Writer, origPrefix string, origFlags int) { |
||||||
|
log.SetOutput(origW) |
||||||
|
log.SetFlags(origFlags) |
||||||
|
log.SetPrefix(origPrefix) |
||||||
|
tf.Close() |
||||||
|
}(log.Writer(), log.Prefix(), log.Flags()) |
||||||
|
log.SetOutput(tf) |
||||||
|
log.SetFlags(log.Lshortfile) |
||||||
|
log.SetPrefix("debug: ") |
||||||
|
} |
||||||
|
|
||||||
|
// Send back the results to the shell.
|
||||||
|
words, dir, err := internal.Complete(root, args, opts.showFlags, opts.showDescs) |
||||||
|
if err != nil { |
||||||
|
dir = ShellCompDirectiveError |
||||||
|
} |
||||||
|
for _, word := range words { |
||||||
|
fmt.Println(word) |
||||||
|
} |
||||||
|
fmt.Println(":" + strconv.Itoa(int(dir))) |
||||||
|
return err |
||||||
|
}, |
||||||
|
} |
||||||
|
if hide != nil { |
||||||
|
hide(completeCmd) |
||||||
|
} |
||||||
|
|
||||||
|
root.Subcommands = append( |
||||||
|
root.Subcommands, |
||||||
|
&ffcli.Command{ |
||||||
|
Name: "completion", |
||||||
|
ShortUsage: root.Name + " completion <shell> [--flags] [--descs]", |
||||||
|
ShortHelp: "Shell tab-completion scripts.", |
||||||
|
LongHelp: fmt.Sprintf(cobra.UsageTemplate, root.Name), |
||||||
|
|
||||||
|
// Print help if run without args.
|
||||||
|
Exec: func(ctx context.Context, args []string) error { return flag.ErrHelp }, |
||||||
|
|
||||||
|
// Omit the '__complete' subcommand from the 'completion' help.
|
||||||
|
UsageFunc: func(c *ffcli.Command) string { |
||||||
|
// Filter the subcommands to omit '__complete'.
|
||||||
|
s := make([]*ffcli.Command, 0, len(c.Subcommands)) |
||||||
|
for _, sub := range c.Subcommands { |
||||||
|
if !strings.HasPrefix(sub.Name, "__") { |
||||||
|
s = append(s, sub) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Swap in the filtered subcommands list for the rest of the call.
|
||||||
|
defer func(r []*ffcli.Command) { c.Subcommands = r }(c.Subcommands) |
||||||
|
c.Subcommands = s |
||||||
|
|
||||||
|
// Render the usage.
|
||||||
|
if usageFunc == nil { |
||||||
|
return ffcli.DefaultUsageFunc(c) |
||||||
|
} |
||||||
|
return usageFunc(c) |
||||||
|
}, |
||||||
|
|
||||||
|
Subcommands: append( |
||||||
|
scriptCmds(root, usageFunc), |
||||||
|
completeCmd, |
||||||
|
), |
||||||
|
}, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
// Flag registers a completion function for the flag in fs with given name.
|
||||||
|
// comp will always called with a 1-element slice.
|
||||||
|
//
|
||||||
|
// comp will be called to return suggestions when the user tries to tab-complete
|
||||||
|
// '--name=<TAB>' or '--name <TAB>' for the commands using fs.
|
||||||
|
func Flag(fs *flag.FlagSet, name string, comp CompleteFunc) { |
||||||
|
f := fs.Lookup(name) |
||||||
|
if f == nil { |
||||||
|
panic(fmt.Errorf("ffcomplete.Flag: flag %s not found", name)) |
||||||
|
} |
||||||
|
if internal.CompleteFlags == nil { |
||||||
|
internal.CompleteFlags = make(map[*flag.Flag]CompleteFunc) |
||||||
|
} |
||||||
|
internal.CompleteFlags[f] = comp |
||||||
|
} |
||||||
|
|
||||||
|
// Args registers a completion function for the args of cmd.
|
||||||
|
//
|
||||||
|
// comp will be called to return suggestions when the user tries to tab-complete
|
||||||
|
// `prog <TAB>` or `prog subcmd arg1 <TAB>`, for example.
|
||||||
|
func Args(cmd *ffcli.Command, comp CompleteFunc) { |
||||||
|
if internal.CompleteCmds == nil { |
||||||
|
internal.CompleteCmds = make(map[*ffcli.Command]CompleteFunc) |
||||||
|
} |
||||||
|
internal.CompleteCmds[cmd] = comp |
||||||
|
} |
||||||
@ -0,0 +1,17 @@ |
|||||||
|
// Copyright (c) Tailscale Inc & AUTHORS
|
||||||
|
// SPDX-License-Identifier: BSD-3-Clause
|
||||||
|
|
||||||
|
//go:build go1.19 && ts_omit_completion
|
||||||
|
|
||||||
|
package ffcomplete |
||||||
|
|
||||||
|
import ( |
||||||
|
"flag" |
||||||
|
|
||||||
|
"github.com/peterbourgon/ff/v3/ffcli" |
||||||
|
) |
||||||
|
|
||||||
|
func Inject(root *ffcli.Command, hide func(*ffcli.Command), usageFunc func(*ffcli.Command) string) {} |
||||||
|
|
||||||
|
func Flag(fs *flag.FlagSet, name string, comp CompleteFunc) {} |
||||||
|
func Args(cmd *ffcli.Command, comp CompleteFunc) *ffcli.Command { return cmd } |
||||||
@ -0,0 +1,60 @@ |
|||||||
|
// Copyright (c) Tailscale Inc & AUTHORS
|
||||||
|
// SPDX-License-Identifier: BSD-3-Clause
|
||||||
|
|
||||||
|
package ffcomplete |
||||||
|
|
||||||
|
import ( |
||||||
|
"strings" |
||||||
|
|
||||||
|
"tailscale.com/cmd/tailscale/cli/ffcomplete/internal" |
||||||
|
"tailscale.com/tempfork/spf13/cobra" |
||||||
|
) |
||||||
|
|
||||||
|
type ShellCompDirective = cobra.ShellCompDirective |
||||||
|
|
||||||
|
const ( |
||||||
|
ShellCompDirectiveError = cobra.ShellCompDirectiveError |
||||||
|
ShellCompDirectiveNoSpace = cobra.ShellCompDirectiveNoSpace |
||||||
|
ShellCompDirectiveNoFileComp = cobra.ShellCompDirectiveNoFileComp |
||||||
|
ShellCompDirectiveFilterFileExt = cobra.ShellCompDirectiveFilterFileExt |
||||||
|
ShellCompDirectiveFilterDirs = cobra.ShellCompDirectiveFilterDirs |
||||||
|
ShellCompDirectiveKeepOrder = cobra.ShellCompDirectiveKeepOrder |
||||||
|
ShellCompDirectiveDefault = cobra.ShellCompDirectiveDefault |
||||||
|
) |
||||||
|
|
||||||
|
// CompleteFunc is used to return tab-completion suggestions to the user as they
|
||||||
|
// are typing command-line instructions. It returns the list of things to
|
||||||
|
// suggest and an additional directive to the shell about what extra
|
||||||
|
// functionality to enable.
|
||||||
|
type CompleteFunc = internal.CompleteFunc |
||||||
|
|
||||||
|
// LastArg returns the last element of args, or the empty string if args is
|
||||||
|
// empty.
|
||||||
|
func LastArg(args []string) string { |
||||||
|
if len(args) == 0 { |
||||||
|
return "" |
||||||
|
} |
||||||
|
return args[len(args)-1] |
||||||
|
} |
||||||
|
|
||||||
|
// Fixed returns a CompleteFunc which suggests the given words.
|
||||||
|
func Fixed(words ...string) CompleteFunc { |
||||||
|
return func(args []string) ([]string, cobra.ShellCompDirective, error) { |
||||||
|
match := LastArg(args) |
||||||
|
matches := make([]string, 0, len(words)) |
||||||
|
for _, word := range words { |
||||||
|
if strings.HasPrefix(word, match) { |
||||||
|
matches = append(matches, word) |
||||||
|
} |
||||||
|
} |
||||||
|
return matches, cobra.ShellCompDirectiveNoFileComp, nil |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// FilesWithExtensions returns a CompleteFunc that tells the shell to limit file
|
||||||
|
// suggestions to those with the given extensions.
|
||||||
|
func FilesWithExtensions(exts ...string) CompleteFunc { |
||||||
|
return func(args []string) ([]string, cobra.ShellCompDirective, error) { |
||||||
|
return exts, cobra.ShellCompDirectiveFilterFileExt, nil |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,256 @@ |
|||||||
|
// Copyright (c) Tailscale Inc & AUTHORS
|
||||||
|
// SPDX-License-Identifier: BSD-3-Clause
|
||||||
|
|
||||||
|
package internal |
||||||
|
|
||||||
|
import ( |
||||||
|
"flag" |
||||||
|
"fmt" |
||||||
|
"strings" |
||||||
|
|
||||||
|
"github.com/peterbourgon/ff/v3" |
||||||
|
"github.com/peterbourgon/ff/v3/ffcli" |
||||||
|
"tailscale.com/tempfork/spf13/cobra" |
||||||
|
) |
||||||
|
|
||||||
|
var ( |
||||||
|
CompleteCmds map[*ffcli.Command]CompleteFunc |
||||||
|
CompleteFlags map[*flag.Flag]CompleteFunc |
||||||
|
) |
||||||
|
|
||||||
|
type CompleteFunc func([]string) ([]string, cobra.ShellCompDirective, error) |
||||||
|
|
||||||
|
// Complete returns the autocomplete suggestions for the root program and args.
|
||||||
|
//
|
||||||
|
// The returned words do not necessarily need to be prefixed with the last arg
|
||||||
|
// which is being completed. For example, '--bool-flag=' will have completions
|
||||||
|
// 'true' and 'false'.
|
||||||
|
//
|
||||||
|
// "HIDDEN: " is trimmed from the start of Flag Usage's.
|
||||||
|
func Complete(root *ffcli.Command, args []string, startFlags, descs bool) (words []string, dir cobra.ShellCompDirective, err error) { |
||||||
|
// Explicitly log panics.
|
||||||
|
defer func() { |
||||||
|
if r := recover(); r != nil { |
||||||
|
if rerr, ok := err.(error); ok { |
||||||
|
err = fmt.Errorf("panic: %w", rerr) |
||||||
|
} else { |
||||||
|
err = fmt.Errorf("panic: %v", r) |
||||||
|
} |
||||||
|
} |
||||||
|
}() |
||||||
|
|
||||||
|
// Set up the arguments.
|
||||||
|
if len(args) == 0 { |
||||||
|
args = []string{""} |
||||||
|
} |
||||||
|
|
||||||
|
// Completion criteria.
|
||||||
|
completeArg := args[len(args)-1] |
||||||
|
args = args[:len(args)-1] |
||||||
|
emitFlag := startFlags || strings.HasPrefix(completeArg, "-") |
||||||
|
emitArgs := true |
||||||
|
|
||||||
|
// Traverse the command-tree to find the cmd command whose
|
||||||
|
// subcommand, flags, or arguments are being completed.
|
||||||
|
cmd := root |
||||||
|
walk: |
||||||
|
for { |
||||||
|
// Ensure there's a flagset with ContinueOnError set.
|
||||||
|
if cmd.FlagSet == nil { |
||||||
|
cmd.FlagSet = flag.NewFlagSet(cmd.Name, flag.ContinueOnError) |
||||||
|
} |
||||||
|
cmd.FlagSet.Init(cmd.FlagSet.Name(), flag.ContinueOnError) |
||||||
|
|
||||||
|
// Manually split the args so we know when we're completing flags/args.
|
||||||
|
flagArgs, argArgs, flagNeedingValue := splitFlagArgs(cmd.FlagSet, args) |
||||||
|
if flagNeedingValue != "" { |
||||||
|
completeArg = flagNeedingValue + "=" + completeArg |
||||||
|
emitFlag = true |
||||||
|
} |
||||||
|
args = argArgs |
||||||
|
|
||||||
|
// Parse the flags.
|
||||||
|
err := ff.Parse(cmd.FlagSet, flagArgs, cmd.Options...) |
||||||
|
if err != nil { |
||||||
|
return nil, 0, fmt.Errorf("%s flag parsing: %w", cmd.Name, err) |
||||||
|
} |
||||||
|
if cmd.FlagSet.NArg() > 0 { |
||||||
|
// This shouldn't happen if splitFlagArgs is accurately finding the
|
||||||
|
// split between flags and args.
|
||||||
|
_ = false |
||||||
|
} |
||||||
|
if len(args) == 0 { |
||||||
|
break |
||||||
|
} |
||||||
|
|
||||||
|
// Check if the first argument is actually a subcommand.
|
||||||
|
for _, sub := range cmd.Subcommands { |
||||||
|
if strings.EqualFold(sub.Name, args[0]) { |
||||||
|
args = args[1:] |
||||||
|
cmd = sub |
||||||
|
continue walk |
||||||
|
} |
||||||
|
} |
||||||
|
break |
||||||
|
} |
||||||
|
if len(args) > 0 { |
||||||
|
emitFlag = false |
||||||
|
} |
||||||
|
|
||||||
|
// Complete '-flag=...'. If the args ended with '-flag ...' we will have
|
||||||
|
// rewritten to '-flag=...' by now.
|
||||||
|
if emitFlag && strings.HasPrefix(completeArg, "-") && strings.Contains(completeArg, "=") { |
||||||
|
// Don't complete '-flag' later on as the
|
||||||
|
// flag name is terminated by a '='.
|
||||||
|
emitFlag = false |
||||||
|
emitArgs = false |
||||||
|
|
||||||
|
dashFlag, completeVal, _ := strings.Cut(completeArg, "=") |
||||||
|
_, f := cutDash(dashFlag) |
||||||
|
flag := cmd.FlagSet.Lookup(f) |
||||||
|
if flag != nil { |
||||||
|
if comp := CompleteFlags[flag]; comp != nil { |
||||||
|
// Complete custom flag values.
|
||||||
|
var err error |
||||||
|
words, dir, err = comp([]string{completeVal}) |
||||||
|
if err != nil { |
||||||
|
return nil, 0, fmt.Errorf("completing %s flag %s: %w", cmd.Name, flag.Name, err) |
||||||
|
} |
||||||
|
} else if isBoolFlag(flag) { |
||||||
|
// Complete true/false.
|
||||||
|
for _, vals := range [][]string{ |
||||||
|
{"true", "TRUE", "True", "1"}, |
||||||
|
{"false", "FALSE", "False", "0"}, |
||||||
|
} { |
||||||
|
for _, val := range vals { |
||||||
|
if strings.HasPrefix(val, completeVal) { |
||||||
|
words = append(words, val) |
||||||
|
break |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Complete '-flag...'.
|
||||||
|
if emitFlag { |
||||||
|
used := make(map[string]struct{}) |
||||||
|
cmd.FlagSet.Visit(func(f *flag.Flag) { |
||||||
|
used[f.Name] = struct{}{} |
||||||
|
}) |
||||||
|
|
||||||
|
cd, cf := cutDash(completeArg) |
||||||
|
cmd.FlagSet.VisitAll(func(f *flag.Flag) { |
||||||
|
if !strings.HasPrefix(f.Name, cf) { |
||||||
|
return |
||||||
|
} |
||||||
|
// Skip flags already set by the user.
|
||||||
|
if _, seen := used[f.Name]; seen { |
||||||
|
return |
||||||
|
} |
||||||
|
// Suggest single-dash '-v' for single-char flags and
|
||||||
|
// double-dash '--verbose' for longer.
|
||||||
|
d := cd |
||||||
|
if (d == "" || d == "-") && cf == "" && len(f.Name) > 1 { |
||||||
|
d = "--" |
||||||
|
} |
||||||
|
if descs { |
||||||
|
_, usage := flag.UnquoteUsage(f) |
||||||
|
usage = strings.TrimPrefix(usage, "HIDDEN: ") |
||||||
|
if usage != "" { |
||||||
|
words = append(words, d+f.Name+"\t"+usage) |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
words = append(words, d+f.Name) |
||||||
|
}) |
||||||
|
} |
||||||
|
|
||||||
|
if emitArgs { |
||||||
|
// Complete 'sub...'.
|
||||||
|
for _, sub := range cmd.Subcommands { |
||||||
|
if strings.HasPrefix(sub.Name, completeArg) { |
||||||
|
if descs { |
||||||
|
if sub.ShortHelp != "" { |
||||||
|
words = append(words, sub.Name+"\t"+sub.ShortHelp) |
||||||
|
continue |
||||||
|
} |
||||||
|
} |
||||||
|
words = append(words, sub.Name) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Complete custom args.
|
||||||
|
if comp := CompleteCmds[cmd]; comp != nil { |
||||||
|
w, d, err := comp(append(args, completeArg)) |
||||||
|
if err != nil { |
||||||
|
return nil, 0, fmt.Errorf("completing %s args: %w", cmd.Name, err) |
||||||
|
} |
||||||
|
dir = d |
||||||
|
words = append(words, w...) |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Strip any descriptions if they were suppressed.
|
||||||
|
if !descs { |
||||||
|
for i := range words { |
||||||
|
words[i], _, _ = strings.Cut(words[i], "\t") |
||||||
|
} |
||||||
|
} |
||||||
|
return words, dir, nil |
||||||
|
} |
||||||
|
|
||||||
|
// splitFlagArgs separates a list of command-line arguments into arguments
|
||||||
|
// comprising flags and their values, preceding arguments to be passed to the
|
||||||
|
// command. This follows the stdlib 'flag' parsing conventions. If the final
|
||||||
|
// argument is a flag name which takes a value but has no value specified, it is
|
||||||
|
// omitted from flagArgs and argArgs and instead returned in needValue.
|
||||||
|
func splitFlagArgs(fs *flag.FlagSet, args []string) (flagArgs, argArgs []string, flagNeedingValue string) { |
||||||
|
for i := 0; i < len(args); i++ { |
||||||
|
a := args[i] |
||||||
|
if a == "--" { |
||||||
|
return args[:i], args[i+1:], "" |
||||||
|
} |
||||||
|
|
||||||
|
d, f := cutDash(a) |
||||||
|
if d == "" { |
||||||
|
return args[:i], args[i:], "" |
||||||
|
} |
||||||
|
if strings.Contains(f, "=") { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
flag := fs.Lookup(f) |
||||||
|
if flag == nil { |
||||||
|
return args[:i], args[i:], "" |
||||||
|
} |
||||||
|
if isBoolFlag(flag) { |
||||||
|
continue |
||||||
|
} |
||||||
|
|
||||||
|
// Consume an extra argument for the flag value.
|
||||||
|
if i == len(args)-1 { |
||||||
|
return args[:i], nil, args[i] |
||||||
|
} |
||||||
|
i++ |
||||||
|
} |
||||||
|
return args, nil, "" |
||||||
|
} |
||||||
|
|
||||||
|
func cutDash(s string) (dashes, flag string) { |
||||||
|
if strings.HasPrefix(s, "-") { |
||||||
|
if strings.HasPrefix(s[1:], "-") { |
||||||
|
return "--", s[2:] |
||||||
|
} |
||||||
|
return "-", s[1:] |
||||||
|
} |
||||||
|
return "", s |
||||||
|
} |
||||||
|
|
||||||
|
func isBoolFlag(f *flag.Flag) bool { |
||||||
|
bf, ok := f.Value.(interface { |
||||||
|
IsBoolFlag() bool |
||||||
|
}) |
||||||
|
return ok && bf.IsBoolFlag() |
||||||
|
} |
||||||
@ -0,0 +1,219 @@ |
|||||||
|
// Copyright (c) Tailscale Inc & AUTHORS
|
||||||
|
// SPDX-License-Identifier: BSD-3-Clause
|
||||||
|
|
||||||
|
package internal_test |
||||||
|
|
||||||
|
import ( |
||||||
|
_ "embed" |
||||||
|
"flag" |
||||||
|
"strings" |
||||||
|
"testing" |
||||||
|
|
||||||
|
"github.com/google/go-cmp/cmp" |
||||||
|
"github.com/peterbourgon/ff/v3/ffcli" |
||||||
|
"tailscale.com/cmd/tailscale/cli/ffcomplete" |
||||||
|
"tailscale.com/cmd/tailscale/cli/ffcomplete/internal" |
||||||
|
) |
||||||
|
|
||||||
|
func newFlagSet(name string, errh flag.ErrorHandling, flags func(fs *flag.FlagSet)) *flag.FlagSet { |
||||||
|
fs := flag.NewFlagSet(name, errh) |
||||||
|
if flags != nil { |
||||||
|
flags(fs) |
||||||
|
} |
||||||
|
return fs |
||||||
|
} |
||||||
|
|
||||||
|
func TestComplete(t *testing.T) { |
||||||
|
t.Parallel() |
||||||
|
|
||||||
|
// Build our test program in testdata.
|
||||||
|
root := &ffcli.Command{ |
||||||
|
Name: "prog", |
||||||
|
FlagSet: newFlagSet("prog", flag.ContinueOnError, func(fs *flag.FlagSet) { |
||||||
|
fs.Bool("v", false, "verbose") |
||||||
|
fs.Bool("root-bool", false, "root `bool`") |
||||||
|
fs.String("root-str", "", "some `text`") |
||||||
|
}), |
||||||
|
Subcommands: []*ffcli.Command{ |
||||||
|
{ |
||||||
|
Name: "debug", |
||||||
|
ShortHelp: "Debug data", |
||||||
|
FlagSet: newFlagSet("prog debug", flag.ExitOnError, func(fs *flag.FlagSet) { |
||||||
|
fs.String("cpu-profile", "", "write cpu profile to `file`") |
||||||
|
fs.Bool("debug-bool", false, "debug bool") |
||||||
|
fs.Int("level", 0, "a number") |
||||||
|
fs.String("enum", "", "a flag that takes several specific values") |
||||||
|
ffcomplete.Flag(fs, "enum", ffcomplete.Fixed("alpha", "beta", "charlie")) |
||||||
|
}), |
||||||
|
}, |
||||||
|
func() *ffcli.Command { |
||||||
|
cmd := &ffcli.Command{ |
||||||
|
Name: "ping", |
||||||
|
FlagSet: newFlagSet("prog ping", flag.ContinueOnError, func(fs *flag.FlagSet) { |
||||||
|
fs.String("until", "", "when pinging should end") |
||||||
|
ffcomplete.Flag(fs, "until", ffcomplete.Fixed("forever", "direct")) |
||||||
|
}), |
||||||
|
} |
||||||
|
ffcomplete.Args(cmd, ffcomplete.Fixed("jupiter", "neptune", "venus")) |
||||||
|
return cmd |
||||||
|
}(), |
||||||
|
}, |
||||||
|
} |
||||||
|
|
||||||
|
tests := []struct { |
||||||
|
args []string |
||||||
|
showFlags bool |
||||||
|
showDescs bool |
||||||
|
wantComp []string |
||||||
|
wantDir ffcomplete.ShellCompDirective |
||||||
|
}{ |
||||||
|
{ |
||||||
|
args: []string{"deb"}, |
||||||
|
wantComp: []string{"debug"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"deb"}, |
||||||
|
showDescs: true, |
||||||
|
wantComp: []string{"debug\tDebug data"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"-"}, |
||||||
|
wantComp: []string{"--root-bool", "--root-str", "-v"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"--"}, |
||||||
|
wantComp: []string{"--root-bool", "--root-str", "--v"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"-r"}, |
||||||
|
wantComp: []string{"-root-bool", "-root-str"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"--r"}, |
||||||
|
wantComp: []string{"--root-bool", "--root-str"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"--root-str=s", "--r"}, |
||||||
|
wantComp: []string{"--root-bool"}, // omits --root-str which is already set
|
||||||
|
}, |
||||||
|
{ |
||||||
|
// '--' disables flag parsing, so we shouldn't suggest flags.
|
||||||
|
args: []string{"--", "--root"}, |
||||||
|
wantComp: nil, |
||||||
|
}, |
||||||
|
{ |
||||||
|
// '--' is used as the value of '--root-str'.
|
||||||
|
args: []string{"--root-str", "--", "--r"}, |
||||||
|
wantComp: []string{"--root-bool"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
// '--' here is a flag value, so doesn't disable flag parsing.
|
||||||
|
args: []string{"--root-str", "--", "--root"}, |
||||||
|
wantComp: []string{"--root-bool"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
// Equivalent to '--root-str=-- -- --r' meaning '--r' is not
|
||||||
|
// a flag because it's preceded by a '--' argument:
|
||||||
|
// https://go.dev/play/p/UCtftQqVhOD.
|
||||||
|
args: []string{"--root-str", "--", "--", "--r"}, |
||||||
|
wantComp: nil, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"--root-bool="}, |
||||||
|
wantComp: []string{"true", "false"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"--root-bool=t"}, |
||||||
|
wantComp: []string{"true"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"--root-bool=T"}, |
||||||
|
wantComp: []string{"TRUE"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"debug", "--de"}, |
||||||
|
wantComp: []string{"--debug-bool"}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"debug", "--enum="}, |
||||||
|
wantComp: []string{"alpha", "beta", "charlie"}, |
||||||
|
wantDir: ffcomplete.ShellCompDirectiveNoFileComp, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"debug", "--enum=al"}, |
||||||
|
wantComp: []string{"alpha"}, |
||||||
|
wantDir: ffcomplete.ShellCompDirectiveNoFileComp, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"debug", "--level", ""}, |
||||||
|
wantComp: nil, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"debug", "--enum", "b"}, |
||||||
|
wantComp: []string{"beta"}, |
||||||
|
wantDir: ffcomplete.ShellCompDirectiveNoFileComp, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"debug", "--enum", "al"}, |
||||||
|
wantComp: []string{"alpha"}, |
||||||
|
wantDir: ffcomplete.ShellCompDirectiveNoFileComp, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"ping", ""}, |
||||||
|
showFlags: true, |
||||||
|
wantComp: []string{"--until", "jupiter", "neptune", "venus"}, |
||||||
|
wantDir: ffcomplete.ShellCompDirectiveNoFileComp, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"ping", ""}, |
||||||
|
showFlags: true, |
||||||
|
showDescs: true, |
||||||
|
wantComp: []string{ |
||||||
|
"--until\twhen pinging should end", |
||||||
|
"jupiter", |
||||||
|
"neptune", |
||||||
|
"venus", |
||||||
|
}, |
||||||
|
wantDir: ffcomplete.ShellCompDirectiveNoFileComp, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"ping", ""}, |
||||||
|
wantComp: []string{"jupiter", "neptune", "venus"}, |
||||||
|
wantDir: ffcomplete.ShellCompDirectiveNoFileComp, |
||||||
|
}, |
||||||
|
{ |
||||||
|
args: []string{"ping", "j"}, |
||||||
|
wantComp: []string{"jupiter"}, |
||||||
|
wantDir: ffcomplete.ShellCompDirectiveNoFileComp, |
||||||
|
}, |
||||||
|
} |
||||||
|
|
||||||
|
// Run the tests.
|
||||||
|
for _, test := range tests { |
||||||
|
test := test |
||||||
|
name := strings.Join(test.args, "␣") |
||||||
|
if test.showFlags { |
||||||
|
name += "+flags" |
||||||
|
} |
||||||
|
if test.showDescs { |
||||||
|
name += "+descs" |
||||||
|
} |
||||||
|
t.Run(name, func(t *testing.T) { |
||||||
|
// Capture the binary
|
||||||
|
complete, dir, err := internal.Complete(root, test.args, test.showFlags, test.showDescs) |
||||||
|
if err != nil { |
||||||
|
t.Fatalf("completion error: %s", err) |
||||||
|
} |
||||||
|
|
||||||
|
// Test the results match our expectation.
|
||||||
|
if test.wantComp != nil { |
||||||
|
if diff := cmp.Diff(test.wantComp, complete); diff != "" { |
||||||
|
t.Errorf("unexpected completion directives (-want +got):\n%s", diff) |
||||||
|
} |
||||||
|
} |
||||||
|
if test.wantDir != dir { |
||||||
|
t.Errorf("got shell completion directive %[1]d (%[1]s), want %[2]d (%[2]s)", dir, test.wantDir) |
||||||
|
} |
||||||
|
}) |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,85 @@ |
|||||||
|
// Copyright (c) Tailscale Inc & AUTHORS
|
||||||
|
// SPDX-License-Identifier: BSD-3-Clause
|
||||||
|
|
||||||
|
//go:build go1.19 && !ts_omit_completion && !ts_omit_completion_scripts
|
||||||
|
|
||||||
|
package ffcomplete |
||||||
|
|
||||||
|
import ( |
||||||
|
"context" |
||||||
|
"flag" |
||||||
|
"os" |
||||||
|
"strings" |
||||||
|
|
||||||
|
"github.com/peterbourgon/ff/v3/ffcli" |
||||||
|
"tailscale.com/tempfork/spf13/cobra" |
||||||
|
) |
||||||
|
|
||||||
|
func compCmd(fs *flag.FlagSet) string { |
||||||
|
var s strings.Builder |
||||||
|
s.WriteString("completion __complete") |
||||||
|
fs.VisitAll(func(f *flag.Flag) { |
||||||
|
s.WriteString(" --") |
||||||
|
s.WriteString(f.Name) |
||||||
|
s.WriteString("=") |
||||||
|
s.WriteString(f.Value.String()) |
||||||
|
}) |
||||||
|
s.WriteString(" --") |
||||||
|
return s.String() |
||||||
|
} |
||||||
|
|
||||||
|
func scriptCmds(root *ffcli.Command, usageFunc func(*ffcli.Command) string) []*ffcli.Command { |
||||||
|
nameForVar := root.Name |
||||||
|
nameForVar = strings.ReplaceAll(nameForVar, "-", "_") |
||||||
|
nameForVar = strings.ReplaceAll(nameForVar, ":", "_") |
||||||
|
|
||||||
|
var ( |
||||||
|
bashFS = newFS("bash", &compOpts{}) |
||||||
|
zshFS = newFS("zsh", &compOpts{}) |
||||||
|
fishFS = newFS("fish", &compOpts{}) |
||||||
|
pwshFS = newFS("powershell", &compOpts{}) |
||||||
|
) |
||||||
|
|
||||||
|
return []*ffcli.Command{ |
||||||
|
{ |
||||||
|
Name: "bash", |
||||||
|
ShortHelp: "Generate bash shell completion script", |
||||||
|
ShortUsage: ". <( " + root.Name + " completion bash )", |
||||||
|
UsageFunc: usageFunc, |
||||||
|
FlagSet: bashFS, |
||||||
|
Exec: func(ctx context.Context, args []string) error { |
||||||
|
return cobra.ScriptBash(os.Stdout, root.Name, compCmd(bashFS), nameForVar) |
||||||
|
}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
Name: "zsh", |
||||||
|
ShortHelp: "Generate zsh shell completion script", |
||||||
|
ShortUsage: ". <( " + root.Name + " completion zsh )", |
||||||
|
UsageFunc: usageFunc, |
||||||
|
FlagSet: zshFS, |
||||||
|
Exec: func(ctx context.Context, args []string) error { |
||||||
|
return cobra.ScriptZsh(os.Stdout, root.Name, compCmd(zshFS), nameForVar) |
||||||
|
}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
Name: "fish", |
||||||
|
ShortHelp: "Generate fish shell completion script", |
||||||
|
ShortUsage: root.Name + " completion fish | source", |
||||||
|
UsageFunc: usageFunc, |
||||||
|
FlagSet: fishFS, |
||||||
|
Exec: func(ctx context.Context, args []string) error { |
||||||
|
return cobra.ScriptFish(os.Stdout, root.Name, compCmd(fishFS), nameForVar) |
||||||
|
}, |
||||||
|
}, |
||||||
|
{ |
||||||
|
Name: "powershell", |
||||||
|
ShortHelp: "Generate powershell completion script", |
||||||
|
ShortUsage: root.Name + " completion powershell | Out-String | Invoke-Expression", |
||||||
|
UsageFunc: usageFunc, |
||||||
|
FlagSet: pwshFS, |
||||||
|
Exec: func(ctx context.Context, args []string) error { |
||||||
|
return cobra.ScriptPowershell(os.Stdout, root.Name, compCmd(pwshFS), nameForVar) |
||||||
|
}, |
||||||
|
}, |
||||||
|
} |
||||||
|
} |
||||||
@ -0,0 +1,12 @@ |
|||||||
|
// Copyright (c) Tailscale Inc & AUTHORS
|
||||||
|
// SPDX-License-Identifier: BSD-3-Clause
|
||||||
|
|
||||||
|
//go:build go1.19 && !ts_omit_completion && ts_omit_completion_scripts
|
||||||
|
|
||||||
|
package ffcomplete |
||||||
|
|
||||||
|
import "github.com/peterbourgon/ff/v3/ffcli" |
||||||
|
|
||||||
|
func scriptCmds(root *ffcli.Command, usageFunc func(*ffcli.Command) string) []*ffcli.Command { |
||||||
|
return nil |
||||||
|
} |
||||||
@ -0,0 +1,174 @@ |
|||||||
|
Apache License |
||||||
|
Version 2.0, January 2004 |
||||||
|
http://www.apache.org/licenses/ |
||||||
|
|
||||||
|
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION |
||||||
|
|
||||||
|
1. Definitions. |
||||||
|
|
||||||
|
"License" shall mean the terms and conditions for use, reproduction, |
||||||
|
and distribution as defined by Sections 1 through 9 of this document. |
||||||
|
|
||||||
|
"Licensor" shall mean the copyright owner or entity authorized by |
||||||
|
the copyright owner that is granting the License. |
||||||
|
|
||||||
|
"Legal Entity" shall mean the union of the acting entity and all |
||||||
|
other entities that control, are controlled by, or are under common |
||||||
|
control with that entity. For the purposes of this definition, |
||||||
|
"control" means (i) the power, direct or indirect, to cause the |
||||||
|
direction or management of such entity, whether by contract or |
||||||
|
otherwise, or (ii) ownership of fifty percent (50%) or more of the |
||||||
|
outstanding shares, or (iii) beneficial ownership of such entity. |
||||||
|
|
||||||
|
"You" (or "Your") shall mean an individual or Legal Entity |
||||||
|
exercising permissions granted by this License. |
||||||
|
|
||||||
|
"Source" form shall mean the preferred form for making modifications, |
||||||
|
including but not limited to software source code, documentation |
||||||
|
source, and configuration files. |
||||||
|
|
||||||
|
"Object" form shall mean any form resulting from mechanical |
||||||
|
transformation or translation of a Source form, including but |
||||||
|
not limited to compiled object code, generated documentation, |
||||||
|
and conversions to other media types. |
||||||
|
|
||||||
|
"Work" shall mean the work of authorship, whether in Source or |
||||||
|
Object form, made available under the License, as indicated by a |
||||||
|
copyright notice that is included in or attached to the work |
||||||
|
(an example is provided in the Appendix below). |
||||||
|
|
||||||
|
"Derivative Works" shall mean any work, whether in Source or Object |
||||||
|
form, that is based on (or derived from) the Work and for which the |
||||||
|
editorial revisions, annotations, elaborations, or other modifications |
||||||
|
represent, as a whole, an original work of authorship. For the purposes |
||||||
|
of this License, Derivative Works shall not include works that remain |
||||||
|
separable from, or merely link (or bind by name) to the interfaces of, |
||||||
|
the Work and Derivative Works thereof. |
||||||
|
|
||||||
|
"Contribution" shall mean any work of authorship, including |
||||||
|
the original version of the Work and any modifications or additions |
||||||
|
to that Work or Derivative Works thereof, that is intentionally |
||||||
|
submitted to Licensor for inclusion in the Work by the copyright owner |
||||||
|
or by an individual or Legal Entity authorized to submit on behalf of |
||||||
|
the copyright owner. For the purposes of this definition, "submitted" |
||||||
|
means any form of electronic, verbal, or written communication sent |
||||||
|
to the Licensor or its representatives, including but not limited to |
||||||
|
communication on electronic mailing lists, source code control systems, |
||||||
|
and issue tracking systems that are managed by, or on behalf of, the |
||||||
|
Licensor for the purpose of discussing and improving the Work, but |
||||||
|
excluding communication that is conspicuously marked or otherwise |
||||||
|
designated in writing by the copyright owner as "Not a Contribution." |
||||||
|
|
||||||
|
"Contributor" shall mean Licensor and any individual or Legal Entity |
||||||
|
on behalf of whom a Contribution has been received by Licensor and |
||||||
|
subsequently incorporated within the Work. |
||||||
|
|
||||||
|
2. Grant of Copyright License. Subject to the terms and conditions of |
||||||
|
this License, each Contributor hereby grants to You a perpetual, |
||||||
|
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||||
|
copyright license to reproduce, prepare Derivative Works of, |
||||||
|
publicly display, publicly perform, sublicense, and distribute the |
||||||
|
Work and such Derivative Works in Source or Object form. |
||||||
|
|
||||||
|
3. Grant of Patent License. Subject to the terms and conditions of |
||||||
|
this License, each Contributor hereby grants to You a perpetual, |
||||||
|
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||||
|
(except as stated in this section) patent license to make, have made, |
||||||
|
use, offer to sell, sell, import, and otherwise transfer the Work, |
||||||
|
where such license applies only to those patent claims licensable |
||||||
|
by such Contributor that are necessarily infringed by their |
||||||
|
Contribution(s) alone or by combination of their Contribution(s) |
||||||
|
with the Work to which such Contribution(s) was submitted. If You |
||||||
|
institute patent litigation against any entity (including a |
||||||
|
cross-claim or counterclaim in a lawsuit) alleging that the Work |
||||||
|
or a Contribution incorporated within the Work constitutes direct |
||||||
|
or contributory patent infringement, then any patent licenses |
||||||
|
granted to You under this License for that Work shall terminate |
||||||
|
as of the date such litigation is filed. |
||||||
|
|
||||||
|
4. Redistribution. You may reproduce and distribute copies of the |
||||||
|
Work or Derivative Works thereof in any medium, with or without |
||||||
|
modifications, and in Source or Object form, provided that You |
||||||
|
meet the following conditions: |
||||||
|
|
||||||
|
(a) You must give any other recipients of the Work or |
||||||
|
Derivative Works a copy of this License; and |
||||||
|
|
||||||
|
(b) You must cause any modified files to carry prominent notices |
||||||
|
stating that You changed the files; and |
||||||
|
|
||||||
|
(c) You must retain, in the Source form of any Derivative Works |
||||||
|
that You distribute, all copyright, patent, trademark, and |
||||||
|
attribution notices from the Source form of the Work, |
||||||
|
excluding those notices that do not pertain to any part of |
||||||
|
the Derivative Works; and |
||||||
|
|
||||||
|
(d) If the Work includes a "NOTICE" text file as part of its |
||||||
|
distribution, then any Derivative Works that You distribute must |
||||||
|
include a readable copy of the attribution notices contained |
||||||
|
within such NOTICE file, excluding those notices that do not |
||||||
|
pertain to any part of the Derivative Works, in at least one |
||||||
|
of the following places: within a NOTICE text file distributed |
||||||
|
as part of the Derivative Works; within the Source form or |
||||||
|
documentation, if provided along with the Derivative Works; or, |
||||||
|
within a display generated by the Derivative Works, if and |
||||||
|
wherever such third-party notices normally appear. The contents |
||||||
|
of the NOTICE file are for informational purposes only and |
||||||
|
do not modify the License. You may add Your own attribution |
||||||
|
notices within Derivative Works that You distribute, alongside |
||||||
|
or as an addendum to the NOTICE text from the Work, provided |
||||||
|
that such additional attribution notices cannot be construed |
||||||
|
as modifying the License. |
||||||
|
|
||||||
|
You may add Your own copyright statement to Your modifications and |
||||||
|
may provide additional or different license terms and conditions |
||||||
|
for use, reproduction, or distribution of Your modifications, or |
||||||
|
for any such Derivative Works as a whole, provided Your use, |
||||||
|
reproduction, and distribution of the Work otherwise complies with |
||||||
|
the conditions stated in this License. |
||||||
|
|
||||||
|
5. Submission of Contributions. Unless You explicitly state otherwise, |
||||||
|
any Contribution intentionally submitted for inclusion in the Work |
||||||
|
by You to the Licensor shall be under the terms and conditions of |
||||||
|
this License, without any additional terms or conditions. |
||||||
|
Notwithstanding the above, nothing herein shall supersede or modify |
||||||
|
the terms of any separate license agreement you may have executed |
||||||
|
with Licensor regarding such Contributions. |
||||||
|
|
||||||
|
6. Trademarks. This License does not grant permission to use the trade |
||||||
|
names, trademarks, service marks, or product names of the Licensor, |
||||||
|
except as required for reasonable and customary use in describing the |
||||||
|
origin of the Work and reproducing the content of the NOTICE file. |
||||||
|
|
||||||
|
7. Disclaimer of Warranty. Unless required by applicable law or |
||||||
|
agreed to in writing, Licensor provides the Work (and each |
||||||
|
Contributor provides its Contributions) on an "AS IS" BASIS, |
||||||
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
||||||
|
implied, including, without limitation, any warranties or conditions |
||||||
|
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A |
||||||
|
PARTICULAR PURPOSE. You are solely responsible for determining the |
||||||
|
appropriateness of using or redistributing the Work and assume any |
||||||
|
risks associated with Your exercise of permissions under this License. |
||||||
|
|
||||||
|
8. Limitation of Liability. In no event and under no legal theory, |
||||||
|
whether in tort (including negligence), contract, or otherwise, |
||||||
|
unless required by applicable law (such as deliberate and grossly |
||||||
|
negligent acts) or agreed to in writing, shall any Contributor be |
||||||
|
liable to You for damages, including any direct, indirect, special, |
||||||
|
incidental, or consequential damages of any character arising as a |
||||||
|
result of this License or out of the use or inability to use the |
||||||
|
Work (including but not limited to damages for loss of goodwill, |
||||||
|
work stoppage, computer failure or malfunction, or any and all |
||||||
|
other commercial damages or losses), even if such Contributor |
||||||
|
has been advised of the possibility of such damages. |
||||||
|
|
||||||
|
9. Accepting Warranty or Additional Liability. While redistributing |
||||||
|
the Work or Derivative Works thereof, You may choose to offer, |
||||||
|
and charge a fee for, acceptance of support, warranty, indemnity, |
||||||
|
or other liability obligations and/or rights consistent with this |
||||||
|
License. However, in accepting such obligations, You may act only |
||||||
|
on Your own behalf and on Your sole responsibility, not on behalf |
||||||
|
of any other Contributor, and only if You agree to indemnify, |
||||||
|
defend, and hold each Contributor harmless for any liability |
||||||
|
incurred by, or claims asserted against, such Contributor by reason |
||||||
|
of your accepting any such warranty or additional liability. |
||||||
@ -0,0 +1,10 @@ |
|||||||
|
# github.com/spf13/cobra |
||||||
|
|
||||||
|
This package contains a copy of the Apache 2.0-licensed shell scripts that Cobra |
||||||
|
uses to integrate tab-completion into bash, zsh, fish and powershell, and the |
||||||
|
constants that interface with them. We are re-using these scripts to implement |
||||||
|
similar tab-completion for ffcli and the standard library flag package. |
||||||
|
|
||||||
|
The shell scripts were Go constants in the Cobra code, but we have extracted |
||||||
|
them into separate files to facilitate gzipping them, and have removed the |
||||||
|
activeHelp functionality from them. |
||||||
@ -0,0 +1,139 @@ |
|||||||
|
// Copyright 2013-2023 The Cobra Authors
|
||||||
|
//
|
||||||
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||||
|
// you may not use this file except in compliance with the License.
|
||||||
|
// You may obtain a copy of the License at
|
||||||
|
//
|
||||||
|
// http://www.apache.org/licenses/LICENSE-2.0
|
||||||
|
//
|
||||||
|
// Unless required by applicable law or agreed to in writing, software
|
||||||
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||||
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||||
|
// See the License for the specific language governing permissions and
|
||||||
|
// limitations under the License.
|
||||||
|
|
||||||
|
// Package cobra contains shell scripts and constants copied from
|
||||||
|
// https://github.com/spf13/cobra for use in our own shell tab-completion logic.
|
||||||
|
package cobra |
||||||
|
|
||||||
|
import ( |
||||||
|
"fmt" |
||||||
|
"strings" |
||||||
|
) |
||||||
|
|
||||||
|
// ShellCompDirective is a bit map representing the different behaviors the shell
|
||||||
|
// can be instructed to have once completions have been provided.
|
||||||
|
type ShellCompDirective int |
||||||
|
|
||||||
|
const ( |
||||||
|
// ShellCompDirectiveError indicates an error occurred and completions should be ignored.
|
||||||
|
ShellCompDirectiveError ShellCompDirective = 1 << iota |
||||||
|
|
||||||
|
// ShellCompDirectiveNoSpace indicates that the shell should not add a space
|
||||||
|
// after the completion even if there is a single completion provided.
|
||||||
|
ShellCompDirectiveNoSpace |
||||||
|
|
||||||
|
// ShellCompDirectiveNoFileComp indicates that the shell should not provide
|
||||||
|
// file completion even when no completion is provided.
|
||||||
|
ShellCompDirectiveNoFileComp |
||||||
|
|
||||||
|
// ShellCompDirectiveFilterFileExt indicates that the provided completions
|
||||||
|
// should be used as file extension filters.
|
||||||
|
ShellCompDirectiveFilterFileExt |
||||||
|
|
||||||
|
// ShellCompDirectiveFilterDirs indicates that only directory names should
|
||||||
|
// be provided in file completion. To request directory names within another
|
||||||
|
// directory, the returned completions should specify the directory within
|
||||||
|
// which to search.
|
||||||
|
ShellCompDirectiveFilterDirs |
||||||
|
|
||||||
|
// ShellCompDirectiveKeepOrder indicates that the shell should preserve the order
|
||||||
|
// in which the completions are provided
|
||||||
|
ShellCompDirectiveKeepOrder |
||||||
|
|
||||||
|
// ===========================================================================
|
||||||
|
|
||||||
|
// All directives using iota should be above this one.
|
||||||
|
// For internal use.
|
||||||
|
shellCompDirectiveMaxValue |
||||||
|
|
||||||
|
// ShellCompDirectiveDefault indicates to let the shell perform its default
|
||||||
|
// behavior after completions have been provided.
|
||||||
|
// This one must be last to avoid messing up the iota count.
|
||||||
|
ShellCompDirectiveDefault ShellCompDirective = 0 |
||||||
|
) |
||||||
|
|
||||||
|
// Returns a string listing the different directive enabled in the specified parameter
|
||||||
|
func (d ShellCompDirective) String() string { |
||||||
|
var directives []string |
||||||
|
if d&ShellCompDirectiveError != 0 { |
||||||
|
directives = append(directives, "ShellCompDirectiveError") |
||||||
|
} |
||||||
|
if d&ShellCompDirectiveNoSpace != 0 { |
||||||
|
directives = append(directives, "ShellCompDirectiveNoSpace") |
||||||
|
} |
||||||
|
if d&ShellCompDirectiveNoFileComp != 0 { |
||||||
|
directives = append(directives, "ShellCompDirectiveNoFileComp") |
||||||
|
} |
||||||
|
if d&ShellCompDirectiveFilterFileExt != 0 { |
||||||
|
directives = append(directives, "ShellCompDirectiveFilterFileExt") |
||||||
|
} |
||||||
|
if d&ShellCompDirectiveFilterDirs != 0 { |
||||||
|
directives = append(directives, "ShellCompDirectiveFilterDirs") |
||||||
|
} |
||||||
|
if d&ShellCompDirectiveKeepOrder != 0 { |
||||||
|
directives = append(directives, "ShellCompDirectiveKeepOrder") |
||||||
|
} |
||||||
|
if len(directives) == 0 { |
||||||
|
directives = append(directives, "ShellCompDirectiveDefault") |
||||||
|
} |
||||||
|
|
||||||
|
if d >= shellCompDirectiveMaxValue { |
||||||
|
return fmt.Sprintf("ERROR: unexpected ShellCompDirective value: %d", d) |
||||||
|
} |
||||||
|
return strings.Join(directives, " | ") |
||||||
|
} |
||||||
|
|
||||||
|
const UsageTemplate = `To load completions: |
||||||
|
|
||||||
|
Bash: |
||||||
|
|
||||||
|
$ source <(%[1]s completion bash) |
||||||
|
|
||||||
|
# To load completions for each session, execute once: |
||||||
|
# Linux: |
||||||
|
$ %[1]s completion bash > /etc/bash_completion.d/%[1]s |
||||||
|
# macOS: |
||||||
|
$ %[1]s completion bash > $(brew --prefix)/etc/bash_completion.d/%[1]s |
||||||
|
|
||||||
|
Zsh: |
||||||
|
|
||||||
|
# If shell completion is not already enabled in your environment, |
||||||
|
# you will need to enable it. You can execute the following once: |
||||||
|
|
||||||
|
$ echo "autoload -U compinit; compinit" >> ~/.zshrc |
||||||
|
|
||||||
|
# To load completions for each session, execute once: |
||||||
|
$ %[1]s completion zsh > "${fpath[1]}/_%[1]s" |
||||||
|
|
||||||
|
# You will need to start a new shell for this setup to take effect. |
||||||
|
|
||||||
|
fish: |
||||||
|
|
||||||
|
$ %[1]s completion fish | source |
||||||
|
|
||||||
|
# To load completions for each session, execute once: |
||||||
|
$ %[1]s completion fish > ~/.config/fish/completions/%[1]s.fish |
||||||
|
|
||||||
|
PowerShell: |
||||||
|
|
||||||
|
PS> %[1]s completion powershell | Out-String | Invoke-Expression |
||||||
|
|
||||||
|
# To load completions for every new session, run: |
||||||
|
PS> %[1]s completion powershell > %[1]s.ps1 |
||||||
|
# and source this file from your PowerShell profile. |
||||||
|
|
||||||
|
The shell scripts and this help message have been adapted from the |
||||||
|
Cobra project (https://cobra.dev, https://github.com/spf13/cobra)
|
||||||
|
under the Apache-2.0 license. Thank you for making these available. |
||||||
|
` |
||||||
@ -0,0 +1,333 @@ |
|||||||
|
# Copyright 2013-2023 The Cobra Authors |
||||||
|
# |
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
||||||
|
# you may not use this file except in compliance with the License. |
||||||
|
# You may obtain a copy of the License at |
||||||
|
# |
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0 |
||||||
|
# |
||||||
|
# Unless required by applicable law or agreed to in writing, software |
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS, |
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||||
|
# See the License for the specific language governing permissions and |
||||||
|
# limitations under the License. |
||||||
|
|
||||||
|
# bash completion V2 for %-36[1]s -*- shell-script -*- |
||||||
|
|
||||||
|
__%[1]s_debug() |
||||||
|
{ |
||||||
|
if [[ -n ${BASH_COMP_DEBUG_FILE-} ]]; then |
||||||
|
echo "$*" >> "${BASH_COMP_DEBUG_FILE}" |
||||||
|
fi |
||||||
|
} |
||||||
|
|
||||||
|
# Macs have bash3 for which the bash-completion package doesn't include |
||||||
|
# _init_completion. This is a minimal version of that function. |
||||||
|
__%[1]s_init_completion() |
||||||
|
{ |
||||||
|
COMPREPLY=() |
||||||
|
_get_comp_words_by_ref "$@" cur prev words cword |
||||||
|
} |
||||||
|
|
||||||
|
# This function calls the %[1]s program to obtain the completion |
||||||
|
# results and the directive. It fills the 'out' and 'directive' vars. |
||||||
|
__%[1]s_get_completion_results() { |
||||||
|
local requestComp lastParam lastChar args |
||||||
|
|
||||||
|
# Prepare the command to request completions for the program. |
||||||
|
# Calling ${words[0]} instead of directly %[1]s allows handling aliases |
||||||
|
args=("${words[@]:1}") |
||||||
|
requestComp="${words[0]} %[2]s ${args[*]}" |
||||||
|
|
||||||
|
lastParam=${words[$((${#words[@]}-1))]} |
||||||
|
lastChar=${lastParam:$((${#lastParam}-1)):1} |
||||||
|
__%[1]s_debug "lastParam ${lastParam}, lastChar ${lastChar}" |
||||||
|
|
||||||
|
if [[ -z ${cur} && ${lastChar} != = ]]; then |
||||||
|
# If the last parameter is complete (there is a space following it) |
||||||
|
# We add an extra empty parameter so we can indicate this to the go method. |
||||||
|
__%[1]s_debug "Adding extra empty parameter" |
||||||
|
requestComp="${requestComp} ''" |
||||||
|
fi |
||||||
|
|
||||||
|
# When completing a flag with an = (e.g., %[1]s -n=<TAB>) |
||||||
|
# bash focuses on the part after the =, so we need to remove |
||||||
|
# the flag part from $cur |
||||||
|
if [[ ${cur} == -*=* ]]; then |
||||||
|
cur="${cur#*=}" |
||||||
|
fi |
||||||
|
|
||||||
|
__%[1]s_debug "Calling ${requestComp}" |
||||||
|
# Use eval to handle any environment variables and such |
||||||
|
out=$(eval "${requestComp}" 2>/dev/null) |
||||||
|
|
||||||
|
# Extract the directive integer at the very end of the output following a colon (:) |
||||||
|
directive=${out##*:} |
||||||
|
# Remove the directive |
||||||
|
out=${out%%:*} |
||||||
|
if [[ ${directive} == "${out}" ]]; then |
||||||
|
# There is not directive specified |
||||||
|
directive=0 |
||||||
|
fi |
||||||
|
__%[1]s_debug "The completion directive is: ${directive}" |
||||||
|
__%[1]s_debug "The completions are: ${out}" |
||||||
|
} |
||||||
|
|
||||||
|
__%[1]s_process_completion_results() { |
||||||
|
local shellCompDirectiveError=%[3]d |
||||||
|
local shellCompDirectiveNoSpace=%[4]d |
||||||
|
local shellCompDirectiveNoFileComp=%[5]d |
||||||
|
local shellCompDirectiveFilterFileExt=%[6]d |
||||||
|
local shellCompDirectiveFilterDirs=%[7]d |
||||||
|
local shellCompDirectiveKeepOrder=%[8]d |
||||||
|
|
||||||
|
if (((directive & shellCompDirectiveError) != 0)); then |
||||||
|
# Error code. No completion. |
||||||
|
__%[1]s_debug "Received error from custom completion go code" |
||||||
|
return |
||||||
|
else |
||||||
|
if (((directive & shellCompDirectiveNoSpace) != 0)); then |
||||||
|
if [[ $(type -t compopt) == builtin ]]; then |
||||||
|
__%[1]s_debug "Activating no space" |
||||||
|
compopt -o nospace |
||||||
|
else |
||||||
|
__%[1]s_debug "No space directive not supported in this version of bash" |
||||||
|
fi |
||||||
|
fi |
||||||
|
if (((directive & shellCompDirectiveKeepOrder) != 0)); then |
||||||
|
if [[ $(type -t compopt) == builtin ]]; then |
||||||
|
# no sort isn't supported for bash less than < 4.4 |
||||||
|
if [[ ${BASH_VERSINFO[0]} -lt 4 || ( ${BASH_VERSINFO[0]} -eq 4 && ${BASH_VERSINFO[1]} -lt 4 ) ]]; then |
||||||
|
__%[1]s_debug "No sort directive not supported in this version of bash" |
||||||
|
else |
||||||
|
__%[1]s_debug "Activating keep order" |
||||||
|
compopt -o nosort |
||||||
|
fi |
||||||
|
else |
||||||
|
__%[1]s_debug "No sort directive not supported in this version of bash" |
||||||
|
fi |
||||||
|
fi |
||||||
|
if (((directive & shellCompDirectiveNoFileComp) != 0)); then |
||||||
|
if [[ $(type -t compopt) == builtin ]]; then |
||||||
|
__%[1]s_debug "Activating no file completion" |
||||||
|
compopt +o default |
||||||
|
else |
||||||
|
__%[1]s_debug "No file completion directive not supported in this version of bash" |
||||||
|
fi |
||||||
|
fi |
||||||
|
fi |
||||||
|
|
||||||
|
# Separate activeHelp from normal completions |
||||||
|
local completions=() |
||||||
|
while IFS='' read -r comp; do |
||||||
|
completions+=("$comp") |
||||||
|
done <<<"${out}" |
||||||
|
|
||||||
|
if (((directive & shellCompDirectiveFilterFileExt) != 0)); then |
||||||
|
# File extension filtering |
||||||
|
local fullFilter filter filteringCmd |
||||||
|
|
||||||
|
# Do not use quotes around the $completions variable or else newline |
||||||
|
# characters will be kept. |
||||||
|
for filter in ${completions[*]}; do |
||||||
|
fullFilter+="$filter|" |
||||||
|
done |
||||||
|
|
||||||
|
filteringCmd="_filedir $fullFilter" |
||||||
|
__%[1]s_debug "File filtering command: $filteringCmd" |
||||||
|
$filteringCmd |
||||||
|
elif (((directive & shellCompDirectiveFilterDirs) != 0)); then |
||||||
|
# File completion for directories only |
||||||
|
|
||||||
|
local subdir |
||||||
|
subdir=${completions[0]} |
||||||
|
if [[ -n $subdir ]]; then |
||||||
|
__%[1]s_debug "Listing directories in $subdir" |
||||||
|
pushd "$subdir" >/dev/null 2>&1 && _filedir -d && popd >/dev/null 2>&1 || return |
||||||
|
else |
||||||
|
__%[1]s_debug "Listing directories in ." |
||||||
|
_filedir -d |
||||||
|
fi |
||||||
|
else |
||||||
|
__%[1]s_handle_completion_types |
||||||
|
fi |
||||||
|
|
||||||
|
__%[1]s_handle_special_char "$cur" : |
||||||
|
__%[1]s_handle_special_char "$cur" = |
||||||
|
|
||||||
|
# Print the activeHelp statements before we finish |
||||||
|
if ((${#activeHelp[*]} != 0)); then |
||||||
|
printf "\n"; |
||||||
|
printf "%%s\n" "${activeHelp[@]}" |
||||||
|
printf "\n" |
||||||
|
|
||||||
|
# The prompt format is only available from bash 4.4. |
||||||
|
# We test if it is available before using it. |
||||||
|
if (x=${PS1@P}) 2> /dev/null; then |
||||||
|
printf "%%s" "${PS1@P}${COMP_LINE[@]}" |
||||||
|
else |
||||||
|
# Can't print the prompt. Just print the |
||||||
|
# text the user had typed, it is workable enough. |
||||||
|
printf "%%s" "${COMP_LINE[@]}" |
||||||
|
fi |
||||||
|
fi |
||||||
|
} |
||||||
|
|
||||||
|
__%[1]s_handle_completion_types() { |
||||||
|
__%[1]s_debug "__%[1]s_handle_completion_types: COMP_TYPE is $COMP_TYPE" |
||||||
|
|
||||||
|
case $COMP_TYPE in |
||||||
|
37|42) |
||||||
|
# Type: menu-complete/menu-complete-backward and insert-completions |
||||||
|
# If the user requested inserting one completion at a time, or all |
||||||
|
# completions at once on the command-line we must remove the descriptions. |
||||||
|
# https://github.com/spf13/cobra/issues/1508 |
||||||
|
local tab=$'\t' comp |
||||||
|
while IFS='' read -r comp; do |
||||||
|
[[ -z $comp ]] && continue |
||||||
|
# Strip any description |
||||||
|
comp=${comp%%%%$tab*} |
||||||
|
# Only consider the completions that match |
||||||
|
if [[ $comp == "$cur"* ]]; then |
||||||
|
COMPREPLY+=("$comp") |
||||||
|
fi |
||||||
|
done < <(printf "%%s\n" "${completions[@]}") |
||||||
|
;; |
||||||
|
|
||||||
|
*) |
||||||
|
# Type: complete (normal completion) |
||||||
|
__%[1]s_handle_standard_completion_case |
||||||
|
;; |
||||||
|
esac |
||||||
|
} |
||||||
|
|
||||||
|
__%[1]s_handle_standard_completion_case() { |
||||||
|
local tab=$'\t' comp |
||||||
|
|
||||||
|
# Short circuit to optimize if we don't have descriptions |
||||||
|
if [[ "${completions[*]}" != *$tab* ]]; then |
||||||
|
IFS=$'\n' read -ra COMPREPLY -d '' < <(compgen -W "${completions[*]}" -- "$cur") |
||||||
|
return 0 |
||||||
|
fi |
||||||
|
|
||||||
|
local longest=0 |
||||||
|
local compline |
||||||
|
# Look for the longest completion so that we can format things nicely |
||||||
|
while IFS='' read -r compline; do |
||||||
|
[[ -z $compline ]] && continue |
||||||
|
# Strip any description before checking the length |
||||||
|
comp=${compline%%%%$tab*} |
||||||
|
# Only consider the completions that match |
||||||
|
[[ $comp == "$cur"* ]] || continue |
||||||
|
COMPREPLY+=("$compline") |
||||||
|
if ((${#comp}>longest)); then |
||||||
|
longest=${#comp} |
||||||
|
fi |
||||||
|
done < <(printf "%%s\n" "${completions[@]}") |
||||||
|
|
||||||
|
# If there is a single completion left, remove the description text |
||||||
|
if ((${#COMPREPLY[*]} == 1)); then |
||||||
|
__%[1]s_debug "COMPREPLY[0]: ${COMPREPLY[0]}" |
||||||
|
comp="${COMPREPLY[0]%%%%$tab*}" |
||||||
|
__%[1]s_debug "Removed description from single completion, which is now: ${comp}" |
||||||
|
COMPREPLY[0]=$comp |
||||||
|
else # Format the descriptions |
||||||
|
__%[1]s_format_comp_descriptions $longest |
||||||
|
fi |
||||||
|
} |
||||||
|
|
||||||
|
__%[1]s_handle_special_char() |
||||||
|
{ |
||||||
|
local comp="$1" |
||||||
|
local char=$2 |
||||||
|
if [[ "$comp" == *${char}* && "$COMP_WORDBREAKS" == *${char}* ]]; then |
||||||
|
local word=${comp%%"${comp##*${char}}"} |
||||||
|
local idx=${#COMPREPLY[*]} |
||||||
|
while ((--idx >= 0)); do |
||||||
|
COMPREPLY[idx]=${COMPREPLY[idx]#"$word"} |
||||||
|
done |
||||||
|
fi |
||||||
|
} |
||||||
|
|
||||||
|
__%[1]s_format_comp_descriptions() |
||||||
|
{ |
||||||
|
local tab=$'\t' |
||||||
|
local comp desc maxdesclength |
||||||
|
local longest=$1 |
||||||
|
|
||||||
|
local i ci |
||||||
|
for ci in ${!COMPREPLY[*]}; do |
||||||
|
comp=${COMPREPLY[ci]} |
||||||
|
# Properly format the description string which follows a tab character if there is one |
||||||
|
if [[ "$comp" == *$tab* ]]; then |
||||||
|
__%[1]s_debug "Original comp: $comp" |
||||||
|
desc=${comp#*$tab} |
||||||
|
comp=${comp%%%%$tab*} |
||||||
|
|
||||||
|
# $COLUMNS stores the current shell width. |
||||||
|
# Remove an extra 4 because we add 2 spaces and 2 parentheses. |
||||||
|
maxdesclength=$(( COLUMNS - longest - 4 )) |
||||||
|
|
||||||
|
# Make sure we can fit a description of at least 8 characters |
||||||
|
# if we are to align the descriptions. |
||||||
|
if ((maxdesclength > 8)); then |
||||||
|
# Add the proper number of spaces to align the descriptions |
||||||
|
for ((i = ${#comp} ; i < longest ; i++)); do |
||||||
|
comp+=" " |
||||||
|
done |
||||||
|
else |
||||||
|
# Don't pad the descriptions so we can fit more text after the completion |
||||||
|
maxdesclength=$(( COLUMNS - ${#comp} - 4 )) |
||||||
|
fi |
||||||
|
|
||||||
|
# If there is enough space for any description text, |
||||||
|
# truncate the descriptions that are too long for the shell width |
||||||
|
if ((maxdesclength > 0)); then |
||||||
|
if ((${#desc} > maxdesclength)); then |
||||||
|
desc=${desc:0:$(( maxdesclength - 1 ))} |
||||||
|
desc+="…" |
||||||
|
fi |
||||||
|
comp+=" ($desc)" |
||||||
|
fi |
||||||
|
COMPREPLY[ci]=$comp |
||||||
|
__%[1]s_debug "Final comp: $comp" |
||||||
|
fi |
||||||
|
done |
||||||
|
} |
||||||
|
|
||||||
|
__start_%[1]s() |
||||||
|
{ |
||||||
|
local cur prev words cword split |
||||||
|
|
||||||
|
COMPREPLY=() |
||||||
|
|
||||||
|
# Call _init_completion from the bash-completion package |
||||||
|
# to prepare the arguments properly |
||||||
|
if declare -F _init_completion >/dev/null 2>&1; then |
||||||
|
_init_completion -n =: || return |
||||||
|
else |
||||||
|
__%[1]s_init_completion -n =: || return |
||||||
|
fi |
||||||
|
|
||||||
|
__%[1]s_debug |
||||||
|
__%[1]s_debug "========= starting completion logic ==========" |
||||||
|
__%[1]s_debug "cur is ${cur}, words[*] is ${words[*]}, #words[@] is ${#words[@]}, cword is $cword" |
||||||
|
|
||||||
|
# The user could have moved the cursor backwards on the command-line. |
||||||
|
# We need to trigger completion from the $cword location, so we need |
||||||
|
# to truncate the command-line ($words) up to the $cword location. |
||||||
|
words=("${words[@]:0:$cword+1}") |
||||||
|
__%[1]s_debug "Truncated words[*]: ${words[*]}," |
||||||
|
|
||||||
|
local out directive |
||||||
|
__%[1]s_get_completion_results |
||||||
|
__%[1]s_process_completion_results |
||||||
|
} |
||||||
|
|
||||||
|
if [[ $(type -t compopt) = "builtin" ]]; then |
||||||
|
complete -o default -F __start_%[1]s %[1]s |
||||||
|
else |
||||||
|
complete -o default -o nospace -F __start_%[1]s %[1]s |
||||||
|
fi |
||||||
|
|
||||||
|
# ex: ts=4 sw=4 et filetype=sh |
||||||
Binary file not shown.
@ -0,0 +1,248 @@ |
|||||||
|
# Copyright 2013-2023 The Cobra Authors |
||||||
|
# |
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
||||||
|
# you may not use this file except in compliance with the License. |
||||||
|
# You may obtain a copy of the License at |
||||||
|
# |
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0 |
||||||
|
# |
||||||
|
# Unless required by applicable law or agreed to in writing, software |
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS, |
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||||
|
# See the License for the specific language governing permissions and |
||||||
|
# limitations under the License. |
||||||
|
|
||||||
|
# fish completion for %-36[1]s -*- shell-script -*- |
||||||
|
|
||||||
|
function __%[1]s_debug |
||||||
|
set -l file "$BASH_COMP_DEBUG_FILE" |
||||||
|
if test -n "$file" |
||||||
|
echo "$argv" >> $file |
||||||
|
end |
||||||
|
end |
||||||
|
|
||||||
|
function __%[1]s_perform_completion |
||||||
|
__%[1]s_debug "Starting __%[1]s_perform_completion" |
||||||
|
|
||||||
|
# Extract all args except the last one |
||||||
|
set -l args (commandline -opc) |
||||||
|
# Extract the last arg and escape it in case it is a space |
||||||
|
set -l lastArg (string escape -- (commandline -ct)) |
||||||
|
|
||||||
|
__%[1]s_debug "args: $args" |
||||||
|
__%[1]s_debug "last arg: $lastArg" |
||||||
|
|
||||||
|
set -l requestComp "$args[1] %[3]s $args[2..-1] $lastArg" |
||||||
|
|
||||||
|
__%[1]s_debug "Calling $requestComp" |
||||||
|
set -l results (eval $requestComp 2> /dev/null) |
||||||
|
|
||||||
|
# Some programs may output extra empty lines after the directive. |
||||||
|
# Let's ignore them or else it will break completion. |
||||||
|
# Ref: https://github.com/spf13/cobra/issues/1279 |
||||||
|
for line in $results[-1..1] |
||||||
|
if test (string trim -- $line) = "" |
||||||
|
# Found an empty line, remove it |
||||||
|
set results $results[1..-2] |
||||||
|
else |
||||||
|
# Found non-empty line, we have our proper output |
||||||
|
break |
||||||
|
end |
||||||
|
end |
||||||
|
|
||||||
|
set -l comps $results[1..-2] |
||||||
|
set -l directiveLine $results[-1] |
||||||
|
|
||||||
|
# For Fish, when completing a flag with an = (e.g., <program> -n=<TAB>) |
||||||
|
# completions must be prefixed with the flag |
||||||
|
set -l flagPrefix (string match -r -- '-.*=' "$lastArg") |
||||||
|
|
||||||
|
__%[1]s_debug "Comps: $comps" |
||||||
|
__%[1]s_debug "DirectiveLine: $directiveLine" |
||||||
|
__%[1]s_debug "flagPrefix: $flagPrefix" |
||||||
|
|
||||||
|
for comp in $comps |
||||||
|
printf "%%s%%s\n" "$flagPrefix" "$comp" |
||||||
|
end |
||||||
|
|
||||||
|
printf "%%s\n" "$directiveLine" |
||||||
|
end |
||||||
|
|
||||||
|
# this function limits calls to __%[1]s_perform_completion, by caching the result behind $__%[1]s_perform_completion_once_result |
||||||
|
function __%[1]s_perform_completion_once |
||||||
|
__%[1]s_debug "Starting __%[1]s_perform_completion_once" |
||||||
|
|
||||||
|
if test -n "$__%[1]s_perform_completion_once_result" |
||||||
|
__%[1]s_debug "Seems like a valid result already exists, skipping __%[1]s_perform_completion" |
||||||
|
return 0 |
||||||
|
end |
||||||
|
|
||||||
|
set --global __%[1]s_perform_completion_once_result (__%[1]s_perform_completion) |
||||||
|
if test -z "$__%[1]s_perform_completion_once_result" |
||||||
|
__%[1]s_debug "No completions, probably due to a failure" |
||||||
|
return 1 |
||||||
|
end |
||||||
|
|
||||||
|
__%[1]s_debug "Performed completions and set __%[1]s_perform_completion_once_result" |
||||||
|
return 0 |
||||||
|
end |
||||||
|
|
||||||
|
# this function is used to clear the $__%[1]s_perform_completion_once_result variable after completions are run |
||||||
|
function __%[1]s_clear_perform_completion_once_result |
||||||
|
__%[1]s_debug "" |
||||||
|
__%[1]s_debug "========= clearing previously set __%[1]s_perform_completion_once_result variable ==========" |
||||||
|
set --erase __%[1]s_perform_completion_once_result |
||||||
|
__%[1]s_debug "Successfully erased the variable __%[1]s_perform_completion_once_result" |
||||||
|
end |
||||||
|
|
||||||
|
function __%[1]s_requires_order_preservation |
||||||
|
__%[1]s_debug "" |
||||||
|
__%[1]s_debug "========= checking if order preservation is required ==========" |
||||||
|
|
||||||
|
__%[1]s_perform_completion_once |
||||||
|
if test -z "$__%[1]s_perform_completion_once_result" |
||||||
|
__%[1]s_debug "Error determining if order preservation is required" |
||||||
|
return 1 |
||||||
|
end |
||||||
|
|
||||||
|
set -l directive (string sub --start 2 $__%[1]s_perform_completion_once_result[-1]) |
||||||
|
__%[1]s_debug "Directive is: $directive" |
||||||
|
|
||||||
|
set -l shellCompDirectiveKeepOrder %[9]d |
||||||
|
set -l keeporder (math (math --scale 0 $directive / $shellCompDirectiveKeepOrder) %% 2) |
||||||
|
__%[1]s_debug "Keeporder is: $keeporder" |
||||||
|
|
||||||
|
if test $keeporder -ne 0 |
||||||
|
__%[1]s_debug "This does require order preservation" |
||||||
|
return 0 |
||||||
|
end |
||||||
|
|
||||||
|
__%[1]s_debug "This doesn't require order preservation" |
||||||
|
return 1 |
||||||
|
end |
||||||
|
|
||||||
|
|
||||||
|
# This function does two things: |
||||||
|
# - Obtain the completions and store them in the global __%[1]s_comp_results |
||||||
|
# - Return false if file completion should be performed |
||||||
|
function __%[1]s_prepare_completions |
||||||
|
__%[1]s_debug "" |
||||||
|
__%[1]s_debug "========= starting completion logic ==========" |
||||||
|
|
||||||
|
# Start fresh |
||||||
|
set --erase __%[1]s_comp_results |
||||||
|
|
||||||
|
__%[1]s_perform_completion_once |
||||||
|
__%[1]s_debug "Completion results: $__%[1]s_perform_completion_once_result" |
||||||
|
|
||||||
|
if test -z "$__%[1]s_perform_completion_once_result" |
||||||
|
__%[1]s_debug "No completion, probably due to a failure" |
||||||
|
# Might as well do file completion, in case it helps |
||||||
|
return 1 |
||||||
|
end |
||||||
|
|
||||||
|
set -l directive (string sub --start 2 $__%[1]s_perform_completion_once_result[-1]) |
||||||
|
set --global __%[1]s_comp_results $__%[1]s_perform_completion_once_result[1..-2] |
||||||
|
|
||||||
|
__%[1]s_debug "Completions are: $__%[1]s_comp_results" |
||||||
|
__%[1]s_debug "Directive is: $directive" |
||||||
|
|
||||||
|
set -l shellCompDirectiveError %[4]d |
||||||
|
set -l shellCompDirectiveNoSpace %[5]d |
||||||
|
set -l shellCompDirectiveNoFileComp %[6]d |
||||||
|
set -l shellCompDirectiveFilterFileExt %[7]d |
||||||
|
set -l shellCompDirectiveFilterDirs %[8]d |
||||||
|
|
||||||
|
if test -z "$directive" |
||||||
|
set directive 0 |
||||||
|
end |
||||||
|
|
||||||
|
set -l compErr (math (math --scale 0 $directive / $shellCompDirectiveError) %% 2) |
||||||
|
if test $compErr -eq 1 |
||||||
|
__%[1]s_debug "Received error directive: aborting." |
||||||
|
# Might as well do file completion, in case it helps |
||||||
|
return 1 |
||||||
|
end |
||||||
|
|
||||||
|
set -l filefilter (math (math --scale 0 $directive / $shellCompDirectiveFilterFileExt) %% 2) |
||||||
|
set -l dirfilter (math (math --scale 0 $directive / $shellCompDirectiveFilterDirs) %% 2) |
||||||
|
if test $filefilter -eq 1; or test $dirfilter -eq 1 |
||||||
|
__%[1]s_debug "File extension filtering or directory filtering not supported" |
||||||
|
# Do full file completion instead |
||||||
|
return 1 |
||||||
|
end |
||||||
|
|
||||||
|
set -l nospace (math (math --scale 0 $directive / $shellCompDirectiveNoSpace) %% 2) |
||||||
|
set -l nofiles (math (math --scale 0 $directive / $shellCompDirectiveNoFileComp) %% 2) |
||||||
|
|
||||||
|
__%[1]s_debug "nospace: $nospace, nofiles: $nofiles" |
||||||
|
|
||||||
|
# If we want to prevent a space, or if file completion is NOT disabled, |
||||||
|
# we need to count the number of valid completions. |
||||||
|
# To do so, we will filter on prefix as the completions we have received |
||||||
|
# may not already be filtered so as to allow fish to match on different |
||||||
|
# criteria than the prefix. |
||||||
|
if test $nospace -ne 0; or test $nofiles -eq 0 |
||||||
|
set -l prefix (commandline -t | string escape --style=regex) |
||||||
|
__%[1]s_debug "prefix: $prefix" |
||||||
|
|
||||||
|
set -l completions (string match -r -- "^$prefix.*" $__%[1]s_comp_results) |
||||||
|
set --global __%[1]s_comp_results $completions |
||||||
|
__%[1]s_debug "Filtered completions are: $__%[1]s_comp_results" |
||||||
|
|
||||||
|
# Important not to quote the variable for count to work |
||||||
|
set -l numComps (count $__%[1]s_comp_results) |
||||||
|
__%[1]s_debug "numComps: $numComps" |
||||||
|
|
||||||
|
if test $numComps -eq 1; and test $nospace -ne 0 |
||||||
|
# We must first split on \t to get rid of the descriptions to be |
||||||
|
# able to check what the actual completion will be. |
||||||
|
# We don't need descriptions anyway since there is only a single |
||||||
|
# real completion which the shell will expand immediately. |
||||||
|
set -l split (string split --max 1 \t $__%[1]s_comp_results[1]) |
||||||
|
|
||||||
|
# Fish won't add a space if the completion ends with any |
||||||
|
# of the following characters: @=/:., |
||||||
|
set -l lastChar (string sub -s -1 -- $split) |
||||||
|
if not string match -r -q "[@=/:.,]" -- "$lastChar" |
||||||
|
# In other cases, to support the "nospace" directive we trick the shell |
||||||
|
# by outputting an extra, longer completion. |
||||||
|
__%[1]s_debug "Adding second completion to perform nospace directive" |
||||||
|
set --global __%[1]s_comp_results $split[1] $split[1]. |
||||||
|
__%[1]s_debug "Completions are now: $__%[1]s_comp_results" |
||||||
|
end |
||||||
|
end |
||||||
|
|
||||||
|
if test $numComps -eq 0; and test $nofiles -eq 0 |
||||||
|
# To be consistent with bash and zsh, we only trigger file |
||||||
|
# completion when there are no other completions |
||||||
|
__%[1]s_debug "Requesting file completion" |
||||||
|
return 1 |
||||||
|
end |
||||||
|
end |
||||||
|
|
||||||
|
return 0 |
||||||
|
end |
||||||
|
|
||||||
|
# Since Fish completions are only loaded once the user triggers them, we trigger them ourselves |
||||||
|
# so we can properly delete any completions provided by another script. |
||||||
|
# Only do this if the program can be found, or else fish may print some errors; besides, |
||||||
|
# the existing completions will only be loaded if the program can be found. |
||||||
|
if type -q "%[2]s" |
||||||
|
# The space after the program name is essential to trigger completion for the program |
||||||
|
# and not completion of the program name itself. |
||||||
|
# Also, we use '> /dev/null 2>&1' since '&>' is not supported in older versions of fish. |
||||||
|
complete --do-complete "%[2]s " > /dev/null 2>&1 |
||||||
|
end |
||||||
|
|
||||||
|
# Remove any pre-existing completions for the program since we will be handling all of them. |
||||||
|
complete -c %[2]s -e |
||||||
|
|
||||||
|
# this will get called after the two calls below and clear the $__%[1]s_perform_completion_once_result global |
||||||
|
complete -c %[2]s -n '__%[1]s_clear_perform_completion_once_result' |
||||||
|
# The call to __%[1]s_prepare_completions will setup __%[1]s_comp_results |
||||||
|
# which provides the program's completion choices. |
||||||
|
# If this doesn't require order preservation, we don't use the -k flag |
||||||
|
complete -c %[2]s -n 'not __%[1]s_requires_order_preservation && __%[1]s_prepare_completions' -f -a '$__%[1]s_comp_results' |
||||||
|
# otherwise we use the -k flag |
||||||
|
complete -k -c %[2]s -n '__%[1]s_requires_order_preservation && __%[1]s_prepare_completions' -f -a '$__%[1]s_comp_results' |
||||||
Binary file not shown.
@ -0,0 +1,72 @@ |
|||||||
|
package cobra |
||||||
|
|
||||||
|
import ( |
||||||
|
"bytes" |
||||||
|
"compress/gzip" |
||||||
|
_ "embed" |
||||||
|
"fmt" |
||||||
|
"io" |
||||||
|
) |
||||||
|
|
||||||
|
//go:generate go run gen.go
|
||||||
|
|
||||||
|
//go:embed comp.bash.gz
|
||||||
|
var compBash string |
||||||
|
|
||||||
|
func ScriptBash(w io.Writer, name, compCmd, nameForVar string) error { |
||||||
|
return fmtgz( |
||||||
|
w, compBash, |
||||||
|
name, compCmd, |
||||||
|
ShellCompDirectiveError, ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp, |
||||||
|
ShellCompDirectiveFilterFileExt, ShellCompDirectiveFilterDirs, ShellCompDirectiveKeepOrder, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
//go:embed comp.zsh.gz
|
||||||
|
var compZsh string |
||||||
|
|
||||||
|
func ScriptZsh(w io.Writer, name, compCmd, nameForVar string) error { |
||||||
|
return fmtgz( |
||||||
|
w, compZsh, |
||||||
|
name, compCmd, |
||||||
|
ShellCompDirectiveError, ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp, |
||||||
|
ShellCompDirectiveFilterFileExt, ShellCompDirectiveFilterDirs, ShellCompDirectiveKeepOrder, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
//go:embed comp.fish.gz
|
||||||
|
var compFish string |
||||||
|
|
||||||
|
func ScriptFish(w io.Writer, name, compCmd, nameForVar string) error { |
||||||
|
return fmtgz( |
||||||
|
w, compFish, |
||||||
|
nameForVar, name, compCmd, |
||||||
|
ShellCompDirectiveError, ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp, |
||||||
|
ShellCompDirectiveFilterFileExt, ShellCompDirectiveFilterDirs, ShellCompDirectiveKeepOrder, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
//go:embed comp.ps1.gz
|
||||||
|
var compPowershell string |
||||||
|
|
||||||
|
func ScriptPowershell(w io.Writer, name, compCmd, nameForVar string) error { |
||||||
|
return fmtgz( |
||||||
|
w, compPowershell, |
||||||
|
name, nameForVar, compCmd, |
||||||
|
ShellCompDirectiveError, ShellCompDirectiveNoSpace, ShellCompDirectiveNoFileComp, |
||||||
|
ShellCompDirectiveFilterFileExt, ShellCompDirectiveFilterDirs, ShellCompDirectiveKeepOrder, |
||||||
|
) |
||||||
|
} |
||||||
|
|
||||||
|
func fmtgz(w io.Writer, formatgz string, args ...any) error { |
||||||
|
f, err := gzip.NewReader(bytes.NewBufferString(formatgz)) |
||||||
|
if err != nil { |
||||||
|
return fmt.Errorf("decompressing script: %w", err) |
||||||
|
} |
||||||
|
format, err := io.ReadAll(f) |
||||||
|
if err != nil { |
||||||
|
return fmt.Errorf("decompressing script: %w", err) |
||||||
|
} |
||||||
|
_, err = fmt.Fprintf(w, string(format), args...) |
||||||
|
return err |
||||||
|
} |
||||||
@ -0,0 +1,259 @@ |
|||||||
|
# Copyright 2013-2023 The Cobra Authors |
||||||
|
# |
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
||||||
|
# you may not use this file except in compliance with the License. |
||||||
|
# You may obtain a copy of the License at |
||||||
|
# |
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0 |
||||||
|
# |
||||||
|
# Unless required by applicable law or agreed to in writing, software |
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS, |
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||||
|
# See the License for the specific language governing permissions and |
||||||
|
# limitations under the License. |
||||||
|
|
||||||
|
# powershell completion for %-36[1]s -*- shell-script -*- |
||||||
|
|
||||||
|
function __%[1]s_debug { |
||||||
|
if ($env:BASH_COMP_DEBUG_FILE) { |
||||||
|
"$args" | Out-File -Append -FilePath "$env:BASH_COMP_DEBUG_FILE" |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
filter __%[1]s_escapeStringWithSpecialChars { |
||||||
|
$_ -replace '\s|#|@|\$|;|,|''|\{|\}|\(|\)|"|`|\||<|>|&','`$&' |
||||||
|
} |
||||||
|
|
||||||
|
[scriptblock]${__%[2]sCompleterBlock} = { |
||||||
|
param( |
||||||
|
$WordToComplete, |
||||||
|
$CommandAst, |
||||||
|
$CursorPosition |
||||||
|
) |
||||||
|
|
||||||
|
# Get the current command line and convert into a string |
||||||
|
$Command = $CommandAst.CommandElements |
||||||
|
$Command = "$Command" |
||||||
|
|
||||||
|
__%[1]s_debug "" |
||||||
|
__%[1]s_debug "========= starting completion logic ==========" |
||||||
|
__%[1]s_debug "WordToComplete: $WordToComplete Command: $Command CursorPosition: $CursorPosition" |
||||||
|
|
||||||
|
# The user could have moved the cursor backwards on the command-line. |
||||||
|
# We need to trigger completion from the $CursorPosition location, so we need |
||||||
|
# to truncate the command-line ($Command) up to the $CursorPosition location. |
||||||
|
# Make sure the $Command is longer then the $CursorPosition before we truncate. |
||||||
|
# This happens because the $Command does not include the last space. |
||||||
|
if ($Command.Length -gt $CursorPosition) { |
||||||
|
$Command=$Command.Substring(0,$CursorPosition) |
||||||
|
} |
||||||
|
__%[1]s_debug "Truncated command: $Command" |
||||||
|
|
||||||
|
$ShellCompDirectiveError=%[4]d |
||||||
|
$ShellCompDirectiveNoSpace=%[5]d |
||||||
|
$ShellCompDirectiveNoFileComp=%[6]d |
||||||
|
$ShellCompDirectiveFilterFileExt=%[7]d |
||||||
|
$ShellCompDirectiveFilterDirs=%[8]d |
||||||
|
$ShellCompDirectiveKeepOrder=%[9]d |
||||||
|
|
||||||
|
# Prepare the command to request completions for the program. |
||||||
|
# Split the command at the first space to separate the program and arguments. |
||||||
|
$Program,$Arguments = $Command.Split(" ",2) |
||||||
|
|
||||||
|
$RequestComp="$Program %[3]s $Arguments" |
||||||
|
__%[1]s_debug "RequestComp: $RequestComp" |
||||||
|
|
||||||
|
# we cannot use $WordToComplete because it |
||||||
|
# has the wrong values if the cursor was moved |
||||||
|
# so use the last argument |
||||||
|
if ($WordToComplete -ne "" ) { |
||||||
|
$WordToComplete = $Arguments.Split(" ")[-1] |
||||||
|
} |
||||||
|
__%[1]s_debug "New WordToComplete: $WordToComplete" |
||||||
|
|
||||||
|
|
||||||
|
# Check for flag with equal sign |
||||||
|
$IsEqualFlag = ($WordToComplete -Like "--*=*" ) |
||||||
|
if ( $IsEqualFlag ) { |
||||||
|
__%[1]s_debug "Completing equal sign flag" |
||||||
|
# Remove the flag part |
||||||
|
$Flag,$WordToComplete = $WordToComplete.Split("=",2) |
||||||
|
} |
||||||
|
|
||||||
|
if ( $WordToComplete -eq "" -And ( -Not $IsEqualFlag )) { |
||||||
|
# If the last parameter is complete (there is a space following it) |
||||||
|
# We add an extra empty parameter so we can indicate this to the go method. |
||||||
|
__%[1]s_debug "Adding extra empty parameter" |
||||||
|
# PowerShell 7.2+ changed the way how the arguments are passed to executables, |
||||||
|
# so for pre-7.2 or when Legacy argument passing is enabled we need to use |
||||||
|
# `"`" to pass an empty argument, a "" or '' does not work!!! |
||||||
|
if ($PSVersionTable.PsVersion -lt [version]'7.2.0' -or |
||||||
|
($PSVersionTable.PsVersion -lt [version]'7.3.0' -and -not [ExperimentalFeature]::IsEnabled("PSNativeCommandArgumentPassing")) -or |
||||||
|
(($PSVersionTable.PsVersion -ge [version]'7.3.0' -or [ExperimentalFeature]::IsEnabled("PSNativeCommandArgumentPassing")) -and |
||||||
|
$PSNativeCommandArgumentPassing -eq 'Legacy')) { |
||||||
|
$RequestComp="$RequestComp" + ' `"`"' |
||||||
|
} else { |
||||||
|
$RequestComp="$RequestComp" + ' ""' |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
__%[1]s_debug "Calling $RequestComp" |
||||||
|
# First disable ActiveHelp which is not supported for Powershell |
||||||
|
${env:%[10]s}=0 |
||||||
|
|
||||||
|
#call the command store the output in $out and redirect stderr and stdout to null |
||||||
|
# $Out is an array contains each line per element |
||||||
|
Invoke-Expression -OutVariable out "$RequestComp" 2>&1 | Out-Null |
||||||
|
|
||||||
|
# get directive from last line |
||||||
|
[int]$Directive = $Out[-1].TrimStart(':') |
||||||
|
if ($Directive -eq "") { |
||||||
|
# There is no directive specified |
||||||
|
$Directive = 0 |
||||||
|
} |
||||||
|
__%[1]s_debug "The completion directive is: $Directive" |
||||||
|
|
||||||
|
# remove directive (last element) from out |
||||||
|
$Out = $Out | Where-Object { $_ -ne $Out[-1] } |
||||||
|
__%[1]s_debug "The completions are: $Out" |
||||||
|
|
||||||
|
if (($Directive -band $ShellCompDirectiveError) -ne 0 ) { |
||||||
|
# Error code. No completion. |
||||||
|
__%[1]s_debug "Received error from custom completion go code" |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
$Longest = 0 |
||||||
|
[Array]$Values = $Out | ForEach-Object { |
||||||
|
#Split the output in name and description |
||||||
|
$Name, $Description = $_.Split("`t",2) |
||||||
|
__%[1]s_debug "Name: $Name Description: $Description" |
||||||
|
|
||||||
|
# Look for the longest completion so that we can format things nicely |
||||||
|
if ($Longest -lt $Name.Length) { |
||||||
|
$Longest = $Name.Length |
||||||
|
} |
||||||
|
|
||||||
|
# Set the description to a one space string if there is none set. |
||||||
|
# This is needed because the CompletionResult does not accept an empty string as argument |
||||||
|
if (-Not $Description) { |
||||||
|
$Description = " " |
||||||
|
} |
||||||
|
@{Name="$Name";Description="$Description"} |
||||||
|
} |
||||||
|
|
||||||
|
|
||||||
|
$Space = " " |
||||||
|
if (($Directive -band $ShellCompDirectiveNoSpace) -ne 0 ) { |
||||||
|
# remove the space here |
||||||
|
__%[1]s_debug "ShellCompDirectiveNoSpace is called" |
||||||
|
$Space = "" |
||||||
|
} |
||||||
|
|
||||||
|
if ((($Directive -band $ShellCompDirectiveFilterFileExt) -ne 0 ) -or |
||||||
|
(($Directive -band $ShellCompDirectiveFilterDirs) -ne 0 )) { |
||||||
|
__%[1]s_debug "ShellCompDirectiveFilterFileExt ShellCompDirectiveFilterDirs are not supported" |
||||||
|
|
||||||
|
# return here to prevent the completion of the extensions |
||||||
|
return |
||||||
|
} |
||||||
|
|
||||||
|
$Values = $Values | Where-Object { |
||||||
|
# filter the result |
||||||
|
$_.Name -like "$WordToComplete*" |
||||||
|
|
||||||
|
# Join the flag back if we have an equal sign flag |
||||||
|
if ( $IsEqualFlag ) { |
||||||
|
__%[1]s_debug "Join the equal sign flag back to the completion value" |
||||||
|
$_.Name = $Flag + "=" + $_.Name |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
# we sort the values in ascending order by name if keep order isn't passed |
||||||
|
if (($Directive -band $ShellCompDirectiveKeepOrder) -eq 0 ) { |
||||||
|
$Values = $Values | Sort-Object -Property Name |
||||||
|
} |
||||||
|
|
||||||
|
if (($Directive -band $ShellCompDirectiveNoFileComp) -ne 0 ) { |
||||||
|
__%[1]s_debug "ShellCompDirectiveNoFileComp is called" |
||||||
|
|
||||||
|
if ($Values.Length -eq 0) { |
||||||
|
# Just print an empty string here so the |
||||||
|
# shell does not start to complete paths. |
||||||
|
# We cannot use CompletionResult here because |
||||||
|
# it does not accept an empty string as argument. |
||||||
|
"" |
||||||
|
return |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
# Get the current mode |
||||||
|
$Mode = (Get-PSReadLineKeyHandler | Where-Object {$_.Key -eq "Tab" }).Function |
||||||
|
__%[1]s_debug "Mode: $Mode" |
||||||
|
|
||||||
|
$Values | ForEach-Object { |
||||||
|
|
||||||
|
# store temporary because switch will overwrite $_ |
||||||
|
$comp = $_ |
||||||
|
|
||||||
|
# PowerShell supports three different completion modes |
||||||
|
# - TabCompleteNext (default windows style - on each key press the next option is displayed) |
||||||
|
# - Complete (works like bash) |
||||||
|
# - MenuComplete (works like zsh) |
||||||
|
# You set the mode with Set-PSReadLineKeyHandler -Key Tab -Function <mode> |
||||||
|
|
||||||
|
# CompletionResult Arguments: |
||||||
|
# 1) CompletionText text to be used as the auto completion result |
||||||
|
# 2) ListItemText text to be displayed in the suggestion list |
||||||
|
# 3) ResultType type of completion result |
||||||
|
# 4) ToolTip text for the tooltip with details about the object |
||||||
|
|
||||||
|
switch ($Mode) { |
||||||
|
|
||||||
|
# bash like |
||||||
|
"Complete" { |
||||||
|
|
||||||
|
if ($Values.Length -eq 1) { |
||||||
|
__%[1]s_debug "Only one completion left" |
||||||
|
|
||||||
|
# insert space after value |
||||||
|
[System.Management.Automation.CompletionResult]::new($($comp.Name | __%[1]s_escapeStringWithSpecialChars) + $Space, "$($comp.Name)", 'ParameterValue', "$($comp.Description)") |
||||||
|
|
||||||
|
} else { |
||||||
|
# Add the proper number of spaces to align the descriptions |
||||||
|
while($comp.Name.Length -lt $Longest) { |
||||||
|
$comp.Name = $comp.Name + " " |
||||||
|
} |
||||||
|
|
||||||
|
# Check for empty description and only add parentheses if needed |
||||||
|
if ($($comp.Description) -eq " " ) { |
||||||
|
$Description = "" |
||||||
|
} else { |
||||||
|
$Description = " ($($comp.Description))" |
||||||
|
} |
||||||
|
|
||||||
|
[System.Management.Automation.CompletionResult]::new("$($comp.Name)$Description", "$($comp.Name)$Description", 'ParameterValue', "$($comp.Description)") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
# zsh like |
||||||
|
"MenuComplete" { |
||||||
|
# insert space after value |
||||||
|
# MenuComplete will automatically show the ToolTip of |
||||||
|
# the highlighted value at the bottom of the suggestions. |
||||||
|
[System.Management.Automation.CompletionResult]::new($($comp.Name | __%[1]s_escapeStringWithSpecialChars) + $Space, "$($comp.Name)", 'ParameterValue', "$($comp.Description)") |
||||||
|
} |
||||||
|
|
||||||
|
# TabCompleteNext and in case we get something unknown |
||||||
|
Default { |
||||||
|
# Like MenuComplete but we don't want to add a space here because |
||||||
|
# the user need to press space anyway to get the completion. |
||||||
|
# Description will not be shown because that's not possible with TabCompleteNext |
||||||
|
[System.Management.Automation.CompletionResult]::new($($comp.Name | __%[1]s_escapeStringWithSpecialChars), "$($comp.Name)", 'ParameterValue', "$($comp.Description)") |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
Register-ArgumentCompleter -CommandName '%[1]s' -ScriptBlock ${__%[2]sCompleterBlock} |
||||||
Binary file not shown.
@ -0,0 +1,198 @@ |
|||||||
|
#compdef %[1]s |
||||||
|
compdef _%[1]s %[1]s |
||||||
|
|
||||||
|
# Copyright 2013-2023 The Cobra Authors |
||||||
|
# |
||||||
|
# Licensed under the Apache License, Version 2.0 (the "License"); |
||||||
|
# you may not use this file except in compliance with the License. |
||||||
|
# You may obtain a copy of the License at |
||||||
|
# |
||||||
|
# http://www.apache.org/licenses/LICENSE-2.0 |
||||||
|
# |
||||||
|
# Unless required by applicable law or agreed to in writing, software |
||||||
|
# distributed under the License is distributed on an "AS IS" BASIS, |
||||||
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||||
|
# See the License for the specific language governing permissions and |
||||||
|
# limitations under the License. |
||||||
|
|
||||||
|
# zsh completion for %-36[1]s -*- shell-script -*- |
||||||
|
|
||||||
|
__%[1]s_debug() |
||||||
|
{ |
||||||
|
local file="$BASH_COMP_DEBUG_FILE" |
||||||
|
if [[ -n ${file} ]]; then |
||||||
|
echo "$*" >> "${file}" |
||||||
|
fi |
||||||
|
} |
||||||
|
|
||||||
|
_%[1]s() |
||||||
|
{ |
||||||
|
local shellCompDirectiveError=%[3]d |
||||||
|
local shellCompDirectiveNoSpace=%[4]d |
||||||
|
local shellCompDirectiveNoFileComp=%[5]d |
||||||
|
local shellCompDirectiveFilterFileExt=%[6]d |
||||||
|
local shellCompDirectiveFilterDirs=%[7]d |
||||||
|
local shellCompDirectiveKeepOrder=%[8]d |
||||||
|
|
||||||
|
local lastParam lastChar flagPrefix requestComp out directive comp lastComp noSpace keepOrder |
||||||
|
local -a completions |
||||||
|
|
||||||
|
__%[1]s_debug "\n========= starting completion logic ==========" |
||||||
|
__%[1]s_debug "CURRENT: ${CURRENT}, words[*]: ${words[*]}" |
||||||
|
|
||||||
|
# The user could have moved the cursor backwards on the command-line. |
||||||
|
# We need to trigger completion from the $CURRENT location, so we need |
||||||
|
# to truncate the command-line ($words) up to the $CURRENT location. |
||||||
|
# (We cannot use $CURSOR as its value does not work when a command is an alias.) |
||||||
|
words=("${=words[1,CURRENT]}") |
||||||
|
__%[1]s_debug "Truncated words[*]: ${words[*]}," |
||||||
|
|
||||||
|
lastParam=${words[-1]} |
||||||
|
lastChar=${lastParam[-1]} |
||||||
|
__%[1]s_debug "lastParam: ${lastParam}, lastChar: ${lastChar}" |
||||||
|
|
||||||
|
# For zsh, when completing a flag with an = (e.g., %[1]s -n=<TAB>) |
||||||
|
# completions must be prefixed with the flag |
||||||
|
setopt local_options BASH_REMATCH |
||||||
|
if [[ "${lastParam}" =~ '-.*=' ]]; then |
||||||
|
# We are dealing with a flag with an = |
||||||
|
flagPrefix="-P ${BASH_REMATCH}" |
||||||
|
fi |
||||||
|
|
||||||
|
# Prepare the command to obtain completions |
||||||
|
requestComp="${words[1]} %[2]s ${words[2,-1]}" |
||||||
|
if [ "${lastChar}" = "" ]; then |
||||||
|
# If the last parameter is complete (there is a space following it) |
||||||
|
# We add an extra empty parameter so we can indicate this to the go completion code. |
||||||
|
__%[1]s_debug "Adding extra empty parameter" |
||||||
|
requestComp="${requestComp} \"\"" |
||||||
|
fi |
||||||
|
|
||||||
|
__%[1]s_debug "About to call: eval ${requestComp}" |
||||||
|
|
||||||
|
# Use eval to handle any environment variables and such |
||||||
|
out=$(eval ${requestComp} 2>/dev/null) |
||||||
|
__%[1]s_debug "completion output: ${out}" |
||||||
|
|
||||||
|
# Extract the directive integer following a : from the last line |
||||||
|
local lastLine |
||||||
|
while IFS='\n' read -r line; do |
||||||
|
lastLine=${line} |
||||||
|
done < <(printf "%%s\n" "${out[@]}") |
||||||
|
__%[1]s_debug "last line: ${lastLine}" |
||||||
|
|
||||||
|
if [ "${lastLine[1]}" = : ]; then |
||||||
|
directive=${lastLine[2,-1]} |
||||||
|
# Remove the directive including the : and the newline |
||||||
|
local suffix |
||||||
|
(( suffix=${#lastLine}+2)) |
||||||
|
out=${out[1,-$suffix]} |
||||||
|
else |
||||||
|
# There is no directive specified. Leave $out as is. |
||||||
|
__%[1]s_debug "No directive found. Setting do default" |
||||||
|
directive=0 |
||||||
|
fi |
||||||
|
|
||||||
|
__%[1]s_debug "directive: ${directive}" |
||||||
|
__%[1]s_debug "completions: ${out}" |
||||||
|
__%[1]s_debug "flagPrefix: ${flagPrefix}" |
||||||
|
|
||||||
|
if [ $((directive & shellCompDirectiveError)) -ne 0 ]; then |
||||||
|
__%[1]s_debug "Completion received error. Ignoring completions." |
||||||
|
return |
||||||
|
fi |
||||||
|
|
||||||
|
while IFS='\n' read -r comp; do |
||||||
|
if [ -n "$comp" ]; then |
||||||
|
# If requested, completions are returned with a description. |
||||||
|
# The description is preceded by a TAB character. |
||||||
|
# For zsh's _describe, we need to use a : instead of a TAB. |
||||||
|
# We first need to escape any : as part of the completion itself. |
||||||
|
comp=${comp//:/\\:} |
||||||
|
|
||||||
|
local tab="$(printf '\t')" |
||||||
|
comp=${comp//$tab/:} |
||||||
|
|
||||||
|
__%[1]s_debug "Adding completion: ${comp}" |
||||||
|
completions+=${comp} |
||||||
|
lastComp=$comp |
||||||
|
fi |
||||||
|
done < <(printf "%%s\n" "${out[@]}") |
||||||
|
|
||||||
|
if [ $((directive & shellCompDirectiveNoSpace)) -ne 0 ]; then |
||||||
|
__%[1]s_debug "Activating nospace." |
||||||
|
noSpace="-S ''" |
||||||
|
fi |
||||||
|
|
||||||
|
if [ $((directive & shellCompDirectiveKeepOrder)) -ne 0 ]; then |
||||||
|
__%[1]s_debug "Activating keep order." |
||||||
|
keepOrder="-V" |
||||||
|
fi |
||||||
|
|
||||||
|
if [ $((directive & shellCompDirectiveFilterFileExt)) -ne 0 ]; then |
||||||
|
# File extension filtering |
||||||
|
local filteringCmd |
||||||
|
filteringCmd='_files' |
||||||
|
for filter in ${completions[@]}; do |
||||||
|
if [ ${filter[1]} != '*' ]; then |
||||||
|
# zsh requires a glob pattern to do file filtering |
||||||
|
filter="\*.$filter" |
||||||
|
fi |
||||||
|
filteringCmd+=" -g $filter" |
||||||
|
done |
||||||
|
filteringCmd+=" ${flagPrefix}" |
||||||
|
|
||||||
|
__%[1]s_debug "File filtering command: $filteringCmd" |
||||||
|
_arguments '*:filename:'"$filteringCmd" |
||||||
|
elif [ $((directive & shellCompDirectiveFilterDirs)) -ne 0 ]; then |
||||||
|
# File completion for directories only |
||||||
|
local subdir |
||||||
|
subdir="${completions[1]}" |
||||||
|
if [ -n "$subdir" ]; then |
||||||
|
__%[1]s_debug "Listing directories in $subdir" |
||||||
|
pushd "${subdir}" >/dev/null 2>&1 |
||||||
|
else |
||||||
|
__%[1]s_debug "Listing directories in ." |
||||||
|
fi |
||||||
|
|
||||||
|
local result |
||||||
|
_arguments '*:dirname:_files -/'" ${flagPrefix}" |
||||||
|
result=$? |
||||||
|
if [ -n "$subdir" ]; then |
||||||
|
popd >/dev/null 2>&1 |
||||||
|
fi |
||||||
|
return $result |
||||||
|
else |
||||||
|
__%[1]s_debug "Calling _describe" |
||||||
|
if eval _describe $keepOrder "completions" completions $flagPrefix $noSpace; then |
||||||
|
__%[1]s_debug "_describe found some completions" |
||||||
|
|
||||||
|
# Return the success of having called _describe |
||||||
|
return 0 |
||||||
|
else |
||||||
|
__%[1]s_debug "_describe did not find completions." |
||||||
|
__%[1]s_debug "Checking if we should do file completion." |
||||||
|
if [ $((directive & shellCompDirectiveNoFileComp)) -ne 0 ]; then |
||||||
|
__%[1]s_debug "deactivating file completion" |
||||||
|
|
||||||
|
# We must return an error code here to let zsh know that there were no |
||||||
|
# completions found by _describe; this is what will trigger other |
||||||
|
# matching algorithms to attempt to find completions. |
||||||
|
# For example zsh can match letters in the middle of words. |
||||||
|
return 1 |
||||||
|
else |
||||||
|
# Perform file completion |
||||||
|
__%[1]s_debug "Activating file completion" |
||||||
|
|
||||||
|
# We must return the result of this command, so it must be the |
||||||
|
# last command, or else we must store its result to return it. |
||||||
|
_arguments '*:filename:_files'" ${flagPrefix}" |
||||||
|
fi |
||||||
|
fi |
||||||
|
fi |
||||||
|
} |
||||||
|
|
||||||
|
# don't run the completion function when being source-ed or eval-ed |
||||||
|
if [ "$funcstack[1]" = "_%[1]s" ]; then |
||||||
|
_%[1]s |
||||||
|
fi |
||||||
Binary file not shown.
@ -0,0 +1,42 @@ |
|||||||
|
//go:build gen
|
||||||
|
|
||||||
|
package main |
||||||
|
|
||||||
|
import ( |
||||||
|
"compress/gzip" |
||||||
|
"fmt" |
||||||
|
"io" |
||||||
|
"os" |
||||||
|
) |
||||||
|
|
||||||
|
func main() { |
||||||
|
for _, name := range []string{"comp.bash", "comp.zsh", "comp.fish", "comp.ps1"} { |
||||||
|
err := compress(name) |
||||||
|
if err != nil { |
||||||
|
fmt.Fprintln(os.Stderr, "compressing "+name+":", err) |
||||||
|
os.Exit(1) |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
func compress(name string) error { |
||||||
|
src, err := os.Open(name) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
defer src.Close() |
||||||
|
|
||||||
|
dst, err := os.Create(name + ".gz") |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
defer dst.Close() |
||||||
|
|
||||||
|
z := gzip.NewWriter(dst) |
||||||
|
_, err = io.Copy(z, src) |
||||||
|
if err != nil { |
||||||
|
return err |
||||||
|
} |
||||||
|
|
||||||
|
return z.Close() |
||||||
|
} |
||||||
Loading…
Reference in new issue