feat(core/autocomplete): complete content of args using list verbs (#2708)

Co-authored-by: Rémy Léone <[email protected]>

Author: Codelax

README.md

@@ -105,6 +105,13 @@ scw instance server list
 scw k8s cluster create name=foo version=1.17.4 pools.0.size=3 pools.0.node-type=DEV1-M pools.0.name=default tags.0=tag1 tags.1=tag2
 ```
 
+## Environment
+
+You can configure your config or enable functionalities with environment variables.
+
+Variables to override config are describe in [config documentation](docs/commands/config.md).
+To enable beta features, you can set `SCW_ENABLE_BETA=1` in your environment.
+
 # Reference documentation
 
 | Namespace      | Description                             | Documentation                                                                                           |

cmd/scw/main.go

@@ -74,6 +74,7 @@ func main() {
 		Stdout:    colorable.NewColorableStdout(),
 		Stderr:    colorable.NewColorableStderr(),
 		Stdin:     os.Stdin,
+		BetaMode:  BetaMode,
 	})
 
 	os.Exit(exitCode)

internal/core/autocomplete.go

@@ -291,7 +291,7 @@ func AutoComplete(ctx context.Context, leftWords []string, wordToComplete string
 	}
 
 	// keep track of the completed args
-	completedArgs := make(map[string]struct{})
+	completedArgs := make(map[string]string)
 
 	// keep track of the completed flags
 	completedFlags := make(map[string]struct{})
@@ -307,12 +307,12 @@ func AutoComplete(ctx context.Context, leftWords []string, wordToComplete string
 
 		// handle arg=value
 		case isArg(word):
-			completedArgs[wordKey(word)+"="] = struct{}{}
+			completedArgs[wordKey(word)+"="] = wordValue(word)
 
 		// handle boolean arg
 		default:
 			if _, exist := node.Children[positionalValueNodeID]; exist && i > nodeIndexInWords {
-				completedArgs[word] = struct{}{}
+				completedArgs[word] = ""
 			}
 		}
 	}
@@ -324,7 +324,7 @@ func AutoComplete(ctx context.Context, leftWords []string, wordToComplete string
 			// We try to complete the value of an unknown arg
 			return &AutocompleteResponse{}
 		}
-		suggestions := AutoCompleteArgValue(ctx, argNode.Command, argNode.ArgSpec, argValuePrefix)
+		suggestions := AutoCompleteArgValue(ctx, argNode.Command, argNode.ArgSpec, argValuePrefix, completedArgs)
 
 		// We need to prefix suggestions with the argName to enable the arg value auto-completion.
 		for k, s := range suggestions {
@@ -338,7 +338,7 @@ func AutoComplete(ctx context.Context, leftWords []string, wordToComplete string
 	suggestions := []string(nil)
 	for key, child := range node.Children {
 		if key == positionalValueNodeID {
-			for _, positionalSuggestion := range AutoCompleteArgValue(ctx, child.Command, child.ArgSpec, wordToComplete) {
+			for _, positionalSuggestion := range AutoCompleteArgValue(ctx, child.Command, child.ArgSpec, wordToComplete, completedArgs) {
 				if _, exists := completedArgs[positionalSuggestion]; !exists {
 					suggestions = append(suggestions, positionalSuggestion)
 				}
@@ -380,7 +380,7 @@ func AutoComplete(ctx context.Context, leftWords []string, wordToComplete string
 // AutoCompleteArgValue returns suggestions for a (argument name, argument value prefix) pair.
 // Priority is given to the AutoCompleteFunc from the ArgSpec, if it is set.
 // Otherwise, we use EnumValues from the ArgSpec.
-func AutoCompleteArgValue(ctx context.Context, cmd *Command, argSpec *ArgSpec, argValuePrefix string) []string {
+func AutoCompleteArgValue(ctx context.Context, cmd *Command, argSpec *ArgSpec, argValuePrefix string, completedArgs map[string]string) []string {
 	if argSpec == nil {
 		return nil
 	}
@@ -401,6 +401,12 @@ func AutoCompleteArgValue(ctx context.Context, cmd *Command, argSpec *ArgSpec, a
 		possibleValues = argSpec.EnumValues
 	}
 
+	// Complete arg value using list verb if possible
+	// "instance server get <tab>" completes "server-id" arg with "id" in instance server list
+	if len(possibleValues) == 0 && ExtractBetaMode(ctx) {
+		possibleValues = AutocompleteGetArg(ctx, cmd, argSpec, completedArgs)
+	}
+
 	suggestions := []string(nil)
 	for _, value := range possibleValues {
 		if strings.HasPrefix(value, argValuePrefix) {
@@ -424,6 +430,14 @@ func wordKey(word string) string {
 	return strings.SplitN(word, "=", 2)[0]
 }
 
+func wordValue(word string) string {
+	words := strings.SplitN(word, "=", 2)
+	if len(words) >= 2 {
+		return words[1]
+	}
+	return ""
+}
+
 func isArg(wordToComplete string) bool {
 	return strings.Contains(wordToComplete, "=")
 }
@@ -460,7 +474,7 @@ func hasPrefix(key, wordToComplete string) bool {
 
 // keySuggestion will suggest the next key available for the map (or array) argument.
 // Keys are suggested in ascending order arg.0, arg.1, arg.2...
-func keySuggestion(key string, completedArg map[string]struct{}, wordToComplete string) []string {
+func keySuggestion(key string, completedArg map[string]string, wordToComplete string) []string {
 	splitKey := strings.Split(key, ".")
 	splitWordToComplete := strings.Split(wordToComplete, ".")
 

internal/core/autocomplete_test.go

@@ -66,37 +66,43 @@ func testAutocompleteGetCommands() *Commands {
 	)
 }
 
+type autoCompleteTestCase struct {
+	Suggestions         AutocompleteSuggestions
+	WordToCompleteIndex int
+	Words               []string
+}
+
+func runAutocompleteTest(ctx context.Context, tc *autoCompleteTestCase) func(*testing.T) {
+	return func(t *testing.T) {
+		words := tc.Words
+		if len(words) == 0 {
+			name := strings.Replace(t.Name(), "TestAutocomplete/", "", -1)
+			name = strings.Replace(name, "_", " ", -1)
+			words = strings.Split(name, " ")
+		}
+
+		wordToCompleteIndex := len(words) - 1
+		if tc.WordToCompleteIndex != 0 {
+			wordToCompleteIndex = tc.WordToCompleteIndex
+		}
+		leftWords := words[:wordToCompleteIndex]
+		wordToComplete := words[wordToCompleteIndex]
+		rightWord := words[wordToCompleteIndex+1:]
+
+		result := AutoComplete(ctx, leftWords, wordToComplete, rightWord)
+		assert.Equal(t, tc.Suggestions, result.Suggestions)
+	}
+}
+
 func TestAutocomplete(t *testing.T) {
 	ctx := injectMeta(context.Background(), &meta{
 		Commands: testAutocompleteGetCommands(),
 	})
 
-	type testCase struct {
-		Suggestions         AutocompleteSuggestions
-		WordToCompleteIndex int
-		Words               []string
-	}
+	type testCase = autoCompleteTestCase
 
 	run := func(tc *testCase) func(*testing.T) {
-		return func(t *testing.T) {
-			words := tc.Words
-			if len(words) == 0 {
-				name := strings.Replace(t.Name(), "TestAutocomplete/", "", -1)
-				name = strings.Replace(name, "_", " ", -1)
-				words = strings.Split(name, " ")
-			}
-
-			wordToCompleteIndex := len(words) - 1
-			if tc.WordToCompleteIndex != 0 {
-				wordToCompleteIndex = tc.WordToCompleteIndex
-			}
-			leftWords := words[:wordToCompleteIndex]
-			wordToComplete := words[wordToCompleteIndex]
-			rightWord := words[wordToCompleteIndex+1:]
-
-			result := AutoComplete(ctx, leftWords, wordToComplete, rightWord)
-			assert.Equal(t, tc.Suggestions, result.Suggestions)
-		}
+		return runAutocompleteTest(ctx, tc)
 	}
 
 	t.Run("scw ", run(&testCase{Suggestions: AutocompleteSuggestions{"test"}}))
@@ -169,3 +175,80 @@ func TestAutocomplete(t *testing.T) {
 	t.Run("scw test flower delete -o json hibiscus w", run(&testCase{Suggestions: AutocompleteSuggestions{"with-leaves="}}))
 	t.Run("scw test flower delete -o=json hibiscus w", run(&testCase{Suggestions: AutocompleteSuggestions{"with-leaves="}}))
 }
+
+func TestAutocompleteArgs(t *testing.T) {
+	commands := testAutocompleteGetCommands()
+	commands.Add(&Command{
+		Namespace: "test",
+		Resource:  "flower",
+		Verb:      "get",
+		ArgsType: reflect.TypeOf(struct {
+			Name         string
+			MaterialName string
+		}{}),
+		ArgSpecs: ArgSpecs{
+			{
+				Name:       "name",
+				Positional: true,
+			},
+			{
+				Name: "material-name",
+			},
+		},
+	})
+	commands.Add(&Command{
+		Namespace: "test",
+		Resource:  "flower",
+		Verb:      "list",
+		ArgsType: reflect.TypeOf(struct {
+		}{}),
+		ArgSpecs: ArgSpecs{},
+		Run: func(ctx context.Context, argsI interface{}) (interface{}, error) {
+			return []*struct {
+				Name string
+			}{
+				{
+					Name: "flower1",
+				},
+				{
+					Name: "flower2",
+				},
+			}, nil
+		},
+	})
+	commands.Add(&Command{
+		Namespace: "test",
+		Resource:  "material",
+		Verb:      "list",
+		ArgsType: reflect.TypeOf(struct {
+		}{}),
+		ArgSpecs: ArgSpecs{},
+		Run: func(ctx context.Context, argsI interface{}) (interface{}, error) {
+			return []*struct {
+				Name string
+			}{
+				{
+					Name: "material1",
+				},
+				{
+					Name: "material2",
+				},
+			}, nil
+		},
+	})
+	ctx := injectMeta(context.Background(), &meta{
+		Commands: commands,
+		betaMode: true,
+	})
+
+	type testCase = autoCompleteTestCase
+
+	run := func(tc *testCase) func(*testing.T) {
+		return runAutocompleteTest(ctx, tc)
+	}
+
+	t.Run("scw test flower get ", run(&testCase{Suggestions: AutocompleteSuggestions{"flower1", "flower2", "material-name="}}))
+	t.Run("scw test flower get material-name=", run(&testCase{Suggestions: AutocompleteSuggestions{"material-name=material1", "material-name=material2"}}))
+	t.Run("scw test flower get material-name=mat ", run(&testCase{Suggestions: AutocompleteSuggestions{"flower1", "flower2"}}))
+	t.Run("scw test flower create name=", run(&testCase{Suggestions: AutocompleteSuggestions(nil)}))
+}

internal/core/autocomplete_utils.go

@@ -2,9 +2,12 @@ package core
 
 import (
 	"context"
+	"reflect"
 	"strings"
 
+	"github.com/scaleway/scaleway-cli/v2/internal/args"
 	"github.com/scaleway/scaleway-sdk-go/scw"
+	"github.com/scaleway/scaleway-sdk-go/strcase"
 )
 
 func AutocompleteProfileName() AutoCompleteArgFunc {
@@ -28,3 +31,91 @@ func AutocompleteProfileName() AutoCompleteArgFunc {
 		return res
 	}
 }
+
+// AutocompleteGetArg tries to complete an argument by using the list verb if it exists for the same resource
+// It will search for the same field in the response of the list
+// Field name will be stripped of the resource name (ex: cluster-id -> id)
+func AutocompleteGetArg(ctx context.Context, cmd *Command, argSpec *ArgSpec, completedArgs map[string]string) []string {
+	commands := ExtractCommands(ctx)
+
+	// The argument we want to find (ex: server-id)
+	argName := argSpec.Name
+	argResource := cmd.Resource
+
+	// if arg name does not start with resource
+	// ex with "scw instance private-nic list server-id=<tab>"
+	// we get server as resource instead of private-nic to find command "scw instance server list"
+	if !strings.HasPrefix(argName, cmd.Resource) {
+		dashIndex := strings.Index(argName, "-")
+		if dashIndex > 0 {
+			argResource = argName[:dashIndex]
+		}
+	}
+
+	// skip if creating a resource and the arg to complete is from the same resource
+	// does not complete name in "scw instance server create name=<tab>"
+	// but still complete for different resources ex: "scw container container create namespace-id=<tab>"
+	if cmd.Verb == "create" && argResource == cmd.Resource {
+		return nil
+	}
+
+	// remove resource from arg name (ex: server-id -> id)
+	argName = strings.TrimPrefix(argName, argResource)
+	argName = strings.TrimLeft(argName, "-")
+
+	listCmd, hasList := commands.find(cmd.Namespace, argResource, "list")
+	if !hasList {
+		return nil
+	}
+
+	// Build empty arguments and run command
+	// Has to use interceptor if it exists as ArgsType could be handled by interceptor
+	listCmdArgs := reflect.New(listCmd.ArgsType).Interface()
+
+	// Keep zone and region arguments
+	listRawArgs := []string(nil)
+	for arg, value := range completedArgs {
+		if strings.HasPrefix(arg, "zone") || strings.HasPrefix(arg, "region") {
+			listRawArgs = append(listRawArgs, arg+value)
+		}
+	}
+
+	// Unmarshal args.
+	// After that we are done working with rawArgs
+	// and will be working with cmdArgs.
+	err := args.UnmarshalStruct(listRawArgs, listCmdArgs)
+	if err != nil {
+		return nil
+	}
+
+	if listCmd.Interceptor == nil {
+		listCmd.Interceptor = func(ctx context.Context, argsI interface{}, runner CommandRunner) (interface{}, error) {
+			return runner(ctx, argsI)
+		}
+	}
+	resp, err := listCmd.Interceptor(ctx, listCmdArgs, listCmd.Run)
+	if err != nil {
+		return nil
+	}
+
+	// As we run the "list" verb instead of using the sdk ListResource, response is already the slice
+	// ex: ListServersResponse -> ListServersResponse.Servers
+	resources := reflect.ValueOf(resp)
+	if resources.Kind() != reflect.Slice {
+		return nil
+	}
+	values := []string(nil)
+	// Let's iterate over the struct in the response slice and get the searched field
+	for i := 0; i < resources.Len(); i++ {
+		resource := resources.Index(i)
+		if resource.Kind() == reflect.Ptr {
+			resource = resource.Elem()
+		}
+		resourceField := resource.FieldByName(strcase.ToPublicGoName(argName))
+		if resourceField.Kind() == reflect.String {
+			values = append(values, resourceField.String())
+		}
+	}
+
+	return values
+}

internal/core/bootstrap.go

@@ -61,6 +61,9 @@ type BootstrapConfig struct {
 	// Default HTTPClient to use. If not provided it will use a basic http client with a simple retry policy
 	// This client will be used to create SDK client, account call, version checking and telemetry
 	HTTPClient *http.Client
+
+	// Enable beta functionalities
+	BetaMode bool
 }
 
 // Bootstrap is the main entry point. It is directly called from main.
@@ -163,6 +166,7 @@ func Bootstrap(config *BootstrapConfig) (exitCode int, result interface{}, err e
 		command:                     nil, // command is later injected by cobra_utils.go/cobraRun()
 		httpClient:                  httpClient,
 		isClientFromBootstrapConfig: isClientFromBootstrapConfig,
+		betaMode:                    config.BetaMode,
 	}
 	// We make sure OverrideEnv is never nil in meta.
 	if meta.OverrideEnv == nil {