completion

package
v1.2.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 14, 2020 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var AppCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)

	applications, err := application.List(context.Client)
	if err != nil {
		return completions
	}

	for _, app := range applications {
		if args.commands[app] {
			return nil
		}
		completions = append(completions, app)
	}
	return
}

AppCompletionHandler provides completion for the app commands

View Source 
var ComponentNameCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)
	components, err := component.List(context.Client, context.Application, nil)

	if err != nil {
		return completions
	}

	for _, component := range components.Items {

		if args.commands[component.Name] {
			return nil
		}
		completions = append(completions, component.Name)
	}
	return completions
}

ComponentNameCompletionHandler provides component name completion

View Source 
var CreateCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)
	catalogList, err := catalog.ListComponents(context.Client)
	if err != nil {
		return completions
	}

	for _, builder := range catalogList.Items {

		if args.commands[builder.Name] {
			return nil
		}
		completions = append(completions, builder.Name)
	}

	return completions
}

CreateCompletionHandler provides component type completion in odo create command

View Source 
var FileCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = append(completions, complete.PredictFiles("*").Predict(args.original)...)
	return
}

FileCompletionHandler provides suggestions for files and directories

View Source 
var LinkCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)
	components, err := component.List(context.Client, context.Application, nil)
	if err != nil {
		return completions
	}

	services, err := service.List(context.Client, context.Application)
	if err != nil {
		return completions
	}

	for _, component := range components.Items {

		if val, ok := args.commands[component.Name]; ok && val {
			return nil
		}

		if component.Name != context.Component() {
			completions = append(completions, component.Name)
		}
	}

	for _, service := range services.Items {

		if val, ok := args.commands[service.ObjectMeta.Name]; ok && val {
			return nil
		}
		completions = append(completions, service.ObjectMeta.Name)
	}

	return completions
}

LinkCompletionHandler provides completion for the odo link The function returns both components and services

View Source 
var ProjectNameCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)
	projects, err := context.Client.GetProjectNames()
	if err != nil {
		return completions
	}

	for _, project := range projects {

		if args.commands[project] {
			return nil
		}
		completions = append(completions, project)
	}
	return completions
}

ProjectNameCompletionHandler provides project name completion

View Source 
var ServiceClassCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)
	services, err := context.Client.GetClusterServiceClasses()
	if err != nil {
		complete.Log("error retrieving services")
		return completions
	}

	complete.Log(fmt.Sprintf("found %d services", len(services)))
	for _, class := range services {
		if args.commands[class.Spec.ExternalName] {
			return nil
		}
		completions = append(completions, class.Spec.ExternalName)
	}

	return
}

ServiceClassCompletionHandler provides catalog service class name completion

View Source 
var ServiceCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)

	services, err := service.List(context.Client, context.Application)
	if err != nil {
		return completions
	}

	for _, class := range services.Items {
		if args.commands[class.ObjectMeta.Name] {
			return nil
		}
		completions = append(completions, class.ObjectMeta.Name)
	}

	return
}

ServiceCompletionHandler provides service name completion for the current project and application

View Source 
var ServiceParameterCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)
	if len(args.original.Completed) < 2 {
		complete.Log("Couldn't extract the service name")
		return completions
	}

	inputServiceName := args.original.Completed[1]
	inputPlanName := args.flagValues["plan"]

	complete.Log(fmt.Sprintf("Using input: serviceName = %s, servicePlan = %s", inputServiceName, inputPlanName))

	_, servicePlans, err := service.GetServiceClassAndPlans(context.Client, inputServiceName)
	if err != nil {
		complete.Log("Error retrieving details of service")
		return completions
	}

	var matchingServicePlan *service.ServicePlan = nil
	if len(servicePlans) == 0 {
		complete.Log("Service has no plans so no parameters can be found")
		return completions
	} else if len(servicePlans) == 1 && inputPlanName == "" {
		matchingServicePlan = &servicePlans[0]
	} else {
		for _, sp := range servicePlans {
			servicePlan := sp
			if servicePlan.Name == inputPlanName {
				matchingServicePlan = &servicePlan
				break
			}
		}
		if matchingServicePlan == nil {
			complete.Log("No service plan for the service matched the supplied plan name")
			return completions
		}
	}

	alreadyAddedParameters := args.flagValues["parameters"]
	for _, servicePlanParameter := range matchingServicePlan.Parameters {

		if !strings.Contains(alreadyAddedParameters, servicePlanParameter.Name) {
			completions = append(completions, servicePlanParameter.Name)
		}
	}

	return completions
}

ServiceParameterCompletionHandler provides completion for the parameter names of a selected service and plan

View Source 
var ServicePlanCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)

	if len(args.original.Completed) < 2 {
		complete.Log("Couldn't extract the service name")
		return completions
	}

	inputServiceName := args.original.Completed[1]

	complete.Log(fmt.Sprintf("Using input: serviceName = %s", inputServiceName))

	clusterServiceClass, err := context.Client.GetClusterServiceClass(inputServiceName)
	if err != nil {
		complete.Log("Error retrieving details of service")
		return completions
	}

	servicePlans, err := context.Client.GetClusterPlansFromServiceName(clusterServiceClass.Name)
	if err != nil {
		complete.Log("Error retrieving details of plans of service")
		return completions
	}

	for _, servicePlan := range servicePlans {
		completions = append(completions, servicePlan.Spec.ExternalName)
	}

	return completions
}

ServicePlanCompletionHandler provides completion for the the plan of a selected service

View Source 
var StorageDeleteCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)

	localConfig, err := config.New()
	if err != nil {
		return completions
	}

	storageList, err := localConfig.StorageList()
	if err != nil {
		return completions
	}

	for _, storage := range storageList {

		if args.commands[storage.Name] {
			return nil
		}
		completions = append(completions, storage.Name)
	}
	return completions
}

StorageDeleteCompletionHandler provides storage name completion for storage delete

View Source 
var StorageMountCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)
	storages, err := storage.ListUnmounted(context.Client, context.Application)
	if err != nil {
		return completions
	}

	for _, storage := range storages.Items {

		if args.commands[storage.Name] {
			return nil
		}
		completions = append(completions, storage.Name)
	}
	return completions
}

StorageMountCompletionHandler provides storage name completion for storage mount

View Source 
var StorageUnMountCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)
	storageList, err := storage.ListMounted(context.Client, context.Component(), context.Application)
	if err != nil {
		return completions
	}

	for _, storage := range storageList.Items {

		if args.commands[storage.Name] {
			return nil
		}
		completions = append(completions, storage.Name)
	}
	return completions
}

StorageUnMountCompletionHandler provides storage name completion for storage unmount

View Source 
var URLCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)

	urls, err := url.ListPushed(context.Client, context.Component(), context.Application)
	if err != nil {
		return completions
	}

	for _, url := range urls.Items {

		if args.commands[url.Name] {
			return nil
		}
		completions = append(completions, url.Name)
	}
	return
}

URLCompletionHandler provides completion for the url commands

View Source 
var UnlinkCompletionHandler = func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) (completions []string) {
	completions = make([]string, 0)

	dcOfCurrentComponent, err := getDCOfComponent(context)
	if err != nil || dcOfCurrentComponent == nil {
		return completions
	}

	components, err := component.List(context.Client, context.Application, nil)
	if err != nil {
		return completions
	}

	services, err := service.List(context.Client, context.Application)
	if err != nil {
		return completions
	}

	for _, component := range components.Items {

		if val, ok := args.commands[component.Name]; ok && val {
			return nil
		}

		if component.Name != context.Component() {

			for _, envFromSourceName := range dcOfCurrentComponent.Spec.Template.Spec.Containers[0].EnvFrom {
				if strings.Contains(envFromSourceName.SecretRef.Name, component.Name) {
					completions = append(completions, component.Name)
				}
			}

		}
	}

	for _, service := range services.Items {

		if val, ok := args.commands[service.ObjectMeta.Name]; ok && val {
			return nil
		}

		for _, envFromSourceName := range dcOfCurrentComponent.Spec.Template.Spec.Containers[0].EnvFrom {
			if strings.Contains(envFromSourceName.SecretRef.Name, service.ObjectMeta.Name) {
				completions = append(completions, service.ObjectMeta.Name)
			}
		}
	}

	return completions
}

LinkCompletionHandler provides completion for the odo link The function returns both components and services

Functions

func GetCommandFlagHandler 

func GetCommandFlagHandler(command *cobra.Command, flag string) (predictor complete.Predictor, ok bool)

GetCommandFlagHandler retrieves the command handler associated with the specified flag of the specified command or nil otherwise

func GetCommandHandler 

func GetCommandHandler(command *cobra.Command) (predictor complete.Predictor, ok bool)

GetCommandHandler retrieves the command handler associated with the specified command or nil otherwise

func NewParsedArgs added in v0.0.16 

func NewParsedArgs(args complete.Args, cmd *cobra.Command) parsedArgs

NewParsedArgs creates a parsed representation of the provided arguments for the specified command. Mostly exposed for tests.

func RegisterCommandFlagHandler 

func RegisterCommandFlagHandler(command *cobra.Command, flag string, predictor ContextualizedPredictor)

RegisterCommandFlagHandler registers the provided ContextualizedPredictor as a completion handler for the specified flag of the specified command

func RegisterCommandHandler 

func RegisterCommandHandler(command *cobra.Command, predictor ContextualizedPredictor)

RegisterCommandHandler registers the provided ContextualizedPredictor as a completion handler for the specified command

Types

type ContextualizedPredictor 

type ContextualizedPredictor func(cmd *cobra.Command, args parsedArgs, context *genericclioptions.Context) []string

ContextualizedPredictor predicts completion based on specified arguments, potentially using the context provided by the specified client to resolve the entities to be completed

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.