Update code-generator to v0.26.0

client/vendor/k8s.io/kube-openapi/pkg/generators/api_linter.go

@@ -20,7 +20,6 @@ import (
 	"bytes"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"sort"
 
@@ -64,7 +63,7 @@ func (a apiViolationFile) VerifyFile(f *generator.File, path string) error {
 	path = a.unmangledPath
 
 	formatted := f.Body.Bytes()
-	existing, err := ioutil.ReadFile(path)
+	existing, err := os.ReadFile(path)
 	if err != nil {
 		return fmt.Errorf("unable to read file %q for comparison: %v", path, err)
 	}

client/vendor/k8s.io/kube-openapi/pkg/generators/enum.go

@@ -55,6 +55,10 @@ func newEnumContext(c *generator.Context) *enumContext {
 // If the given type is a known enum type, returns the enumType, true
 // Otherwise, returns nil, false
 func (ec *enumContext) EnumType(t *types.Type) (enum *enumType, isEnum bool) {
+	// if t is a pointer, use its underlying type instead
+	if t.Kind == types.Pointer {
+		t = t.Elem
+	}
 	enum, ok := ec.enumTypes[t.Name]
 	return enum, ok
 }
@@ -74,9 +78,12 @@ func (et *enumType) ValueStrings() []string {
 // DescriptionLines returns a description of the enum in this format:
 //
 // Possible enum values:
-//  - `"value1"` description 1
-//  - `"value2"` description 2
+//   - `"value1"` description 1
+//   - `"value2"` description 2
 func (et *enumType) DescriptionLines() []string {
+	if len(et.Values) == 0 {
+		return nil
+	}
 	var lines []string
 	for _, value := range et.Values {
 		lines = append(lines, value.Description())
@@ -90,9 +97,9 @@ func parseEnums(c *generator.Context) enumMap {
 	// First, find the builtin "string" type
 	stringType := c.Universe.Type(types.Name{Name: "string"})
 
+	// find all enum types.
 	enumTypes := make(enumMap)
 	for _, p := range c.Universe {
-		// find all enum types.
 		for _, t := range p.Types {
 			if isEnumType(stringType, t) {
 				if _, ok := enumTypes[t.Name]; !ok {
@@ -102,7 +109,10 @@ func parseEnums(c *generator.Context) enumMap {
 				}
 			}
 		}
-		// find all enum values from constants, and try to match each with its type.
+	}
+
+	// find all enum values from constants, and try to match each with its type.
+	for _, p := range c.Universe {
 		for _, c := range p.Constants {
 			enumType := c.Underlying
 			if _, ok := enumTypes[enumType.Name]; ok {
@@ -125,7 +135,7 @@ func (et *enumType) appendValue(value *enumValue) {
 
 // Description returns the description line for the enumValue
 // with the format:
-//  - `"FooValue"` is the Foo value
+//   - `"FooValue"` is the Foo value
 func (ev *enumValue) Description() string {
 	comment := strings.TrimSpace(ev.Comment)
 	// The comment should starts with the type name, trim it first.

client/vendor/k8s.io/kube-openapi/pkg/generators/openapi.go

@@ -686,7 +686,7 @@ func (g openAPITypeWriter) generateProperty(m *types.Member, parent *types.Type)
 		g.generateSimpleProperty(typeString, format)
 		if enumType, isEnum := g.enumContext.EnumType(m.Type); isEnum {
 			// original type is an enum, add "Enum: " and the values
-			g.Do("Enum: []interface{}{$.$}", strings.Join(enumType.ValueStrings(), ", "))
+			g.Do("Enum: []interface{}{$.$},\n", strings.Join(enumType.ValueStrings(), ", "))
 		}
 		g.Do("},\n},\n", nil)
 		return nil

client/vendor/k8s.io/kube-openapi/pkg/generators/rules/names_match.go

@@ -56,24 +56,29 @@ Go field names must be CamelCase. JSON field names must be camelCase. Other than
 initial letter, the two should almost always match. No underscores nor dashes in either.
 This rule verifies the convention "Other than capitalization of the initial letter, the two should almost always match."
 Examples (also in unit test):
-    Go name      | JSON name    | match
-                   podSpec        false
-    PodSpec        podSpec        true
-    PodSpec        PodSpec        false
-    podSpec        podSpec        false
-    PodSpec        spec           false
-    Spec           podSpec        false
-    JSONSpec       jsonSpec       true
-    JSONSpec       jsonspec       false
-    HTTPJSONSpec   httpJSONSpec   true
+
+	Go name      | JSON name    | match
+	               podSpec        false
+	PodSpec        podSpec        true
+	PodSpec        PodSpec        false
+	podSpec        podSpec        false
+	PodSpec        spec           false
+	Spec           podSpec        false
+	JSONSpec       jsonSpec       true
+	JSONSpec       jsonspec       false
+	HTTPJSONSpec   httpJSONSpec   true
+
 NOTE: this validator cannot tell two sequential all-capital words from one word, therefore the case below
 is also considered matched.
-    HTTPJSONSpec   httpjsonSpec   true
+
+	HTTPJSONSpec   httpjsonSpec   true
+
 NOTE: JSON names in jsonNameBlacklist should skip evaluation
-                                  true
-    podSpec                       true
-    podSpec        -              true
-    podSpec        metadata       true
+
+	                              true
+	podSpec                       true
+	podSpec        -              true
+	podSpec        metadata       true
 */
 type NamesMatch struct{}
 
@@ -114,14 +119,15 @@ func (n *NamesMatch) Validate(t *types.Type) ([]string, error) {
 
 // namesMatch evaluates if goName and jsonName match the API rule
 // TODO: Use an off-the-shelf CamelCase solution instead of implementing this logic. The following existing
-//       packages have been tried out:
-//		github.com/markbates/inflect
-//		github.com/segmentio/go-camelcase
-//		github.com/iancoleman/strcase
-//		github.com/fatih/camelcase
-//	 Please see https://github.com/kubernetes/kube-openapi/pull/83#issuecomment-400842314 for more details
-//	 about why they don't satisfy our need. What we need can be a function that detects an acronym at the
-//	 beginning of a string.
+//
+//	      packages have been tried out:
+//			github.com/markbates/inflect
+//			github.com/segmentio/go-camelcase
+//			github.com/iancoleman/strcase
+//			github.com/fatih/camelcase
+//		 Please see https://github.com/kubernetes/kube-openapi/pull/83#issuecomment-400842314 for more details
+//		 about why they don't satisfy our need. What we need can be a function that detects an acronym at the
+//		 beginning of a string.
 func namesMatch(goName, jsonName string) bool {
 	if jsonNameBlacklist.Has(jsonName) {
 		return true