1 files changed, 52 insertions, 24 deletions
diff --git a/cmd/podman/common/completion.go b/cmd/podman/common/completion.go
index 4fec549c1..32dd896c0 100644
--- a/cmd/podman/common/completion.go
+++ b/cmd/podman/common/completion.go
@@ -975,7 +975,7 @@ func convertFormatSuggestions(suggestions []formatSuggestion) []string {
 
 // AutocompleteFormat - Autocomplete json or a given struct to use for a go template.
 // The input can be nil, In this case only json will be autocompleted.
-// This function will only work for structs other types are not supported.
+// This function will only work for pointer to structs other types are not supported.
 // When "{{." is typed the field and method names of the given struct will be completed.
 // This also works recursive for nested structs.
 func AutocompleteFormat(o interface{}) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
@@ -1004,6 +1004,12 @@ func AutocompleteFormat(o interface{}) func(cmd *cobra.Command, args []string, t
 		// split this into it struct field names
 		fields := strings.Split(field[len(field)-1], ".")
 		f := reflect.ValueOf(o)
+		if f.Kind() != reflect.Ptr {
+			// We panic here to make sure that all callers pass the value by reference.
+			// If someone passes a by value then all podman commands will panic since
+			// this function is run at init time.
+			panic("AutocompleteFormat: passed value must be a pointer to a struct")
+		}
 		for i := 1; i < len(fields); i++ {
 			// last field get all names to suggest
 			if i == len(fields)-1 {
@@ -1015,39 +1021,56 @@ func AutocompleteFormat(o interface{}) func(cmd *cobra.Command, args []string, t
 				return prefixSlice(toComplete, convertFormatSuggestions(suggestions)), cobra.ShellCompDirectiveNoSpace | cobra.ShellCompDirectiveNoFileComp
 			}
 
-			val := getActualStructType(f)
-			if val == nil {
-				// no struct return nothing to complete
+			// first follow pointer and create element when it is nil
+			f = actualReflectValue(f)
+			switch f.Kind() {
+			case reflect.Struct:
+				for j := 0; j < f.NumField(); j++ {
+					field := f.Type().Field(j)
+					// ok this is a bit weird but when we have an embedded nil struct
+					// calling FieldByName on a name which is present on this struct will panic
+					// Therefore we have to init them (non nil ptr), https://github.com/containers/podman/issues/14223
+					if field.Anonymous && f.Field(j).Type().Kind() == reflect.Ptr {
+						f.Field(j).Set(reflect.New(f.Field(j).Type().Elem()))
+					}
+				}
+				// set the next struct field
+				f = f.FieldByName(fields[i])
+			case reflect.Map:
+				rtype := f.Type().Elem()
+				if rtype.Kind() == reflect.Ptr {
+					rtype = rtype.Elem()
+				}
+				f = reflect.New(rtype)
+			case reflect.Func:
+				if f.Type().NumOut() != 1 {
+					// unsupported type return nothing
+					return nil, cobra.ShellCompDirectiveNoFileComp
+				}
+				f = reflect.New(f.Type().Out(0))
+			default:
+				// unsupported type return nothing
 				return nil, cobra.ShellCompDirectiveNoFileComp
 			}
-			f = *val
-
-			// set the next struct field
-			f = f.FieldByName(fields[i])
 		}
 		return nil, cobra.ShellCompDirectiveNoFileComp
 	}
 }
 
-// getActualStructType take the value and check if it is a struct,
+// actualReflectValue takes the value,
 // if it is pointer it will dereference it and when it is nil,
-// it will create a new value from it to get the actual struct
-// returns nil when type is not a struct
-func getActualStructType(f reflect.Value) *reflect.Value {
+// it will create a new value from it
+func actualReflectValue(f reflect.Value) reflect.Value {
 	// follow the pointer first
 	if f.Kind() == reflect.Ptr {
 		// if the pointer is nil we create a new value from the elements type
-		// this allows us to follow nil pointers and get the actual struct fields
+		// this allows us to follow nil pointers and get the actual type
 		if f.IsNil() {
 			f = reflect.New(f.Type().Elem())
 		}
 		f = f.Elem()
 	}
-	// we only support structs
-	if f.Kind() != reflect.Struct {
-		return nil
-	}
-	return &f
+	return f
 }
 
 // getStructFields reads all struct field names and method names and returns them.
@@ -1057,12 +1080,11 @@ func getStructFields(f reflect.Value, prefix string) []formatSuggestion {
 		suggestions = append(suggestions, getMethodNames(f, prefix)...)
 	}
 
-	val := getActualStructType(f)
-	if val == nil {
-		// no struct return nothing to complete
+	f = actualReflectValue(f)
+	// we only support structs
+	if f.Kind() != reflect.Struct {
 		return suggestions
 	}
-	f = *val
 
 	var anonymous []formatSuggestion
 	// loop over all field names
@@ -1081,7 +1103,7 @@ func getStructFields(f reflect.Value, prefix string) []formatSuggestion {
 			kind = field.Type.Elem().Kind()
 		}
 		// when we have a nested struct do not append braces instead append a dot
-		if kind == reflect.Struct {
+		if kind == reflect.Struct || kind == reflect.Map {
 			suffix = "."
 		}
 		// if field is anonymous add the child fields as well
@@ -1114,10 +1136,16 @@ func getMethodNames(f reflect.Value, prefix string) []formatSuggestion {
 		if method.Func.Type().NumOut() != 1 {
 			continue
 		}
+		// when we have a nested struct do not append braces instead append a dot
+		kind := method.Func.Type().Out(0).Kind()
+		suffix := "}}"
+		if kind == reflect.Struct || kind == reflect.Map {
+			suffix = "."
+		}
 		fname := method.Name
 		if strings.HasPrefix(fname, prefix) {
 			// add method name with closing braces
-			suggestions = append(suggestions, formatSuggestion{fieldname: fname, suffix: "}}"})
+			suggestions = append(suggestions, formatSuggestion{fieldname: fname, suffix: suffix})
 		}
 	}
 	return suggestions