Migrate CRD, RBAC, and Webhook generators to centralized featuregate package

    - Remove duplicated code across all three generators
    - Update type references and method calls
    - All tests pass with backward compatibility maintained

Author: wazery

go.mod

@@ -10,7 +10,6 @@ require (
 	github.com/onsi/gomega v1.38.0
 	github.com/spf13/cobra v1.9.1
 	github.com/spf13/pflag v1.0.7
-	github.com/stretchr/testify v1.10.0
 	golang.org/x/tools v0.36.0
 	golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated
 	gopkg.in/yaml.v2 v2.4.0
@@ -56,7 +55,6 @@ require (
 	github.com/modern-go/reflect2 v1.0.3-0.20250322232337-35a7c28c31ee // indirect
 	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
 	github.com/nxadm/tail v1.4.8 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/prometheus/client_golang v1.22.0 // indirect
 	github.com/prometheus/client_model v0.6.1 // indirect
 	github.com/prometheus/common v0.62.0 // indirect

pkg/crd/gen.go

@@ -26,53 +26,13 @@ import (
 	apiext "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	crdmarkers "sigs.k8s.io/controller-tools/pkg/crd/markers"
+	"sigs.k8s.io/controller-tools/pkg/featuregate"
 	"sigs.k8s.io/controller-tools/pkg/genall"
 	"sigs.k8s.io/controller-tools/pkg/loader"
 	"sigs.k8s.io/controller-tools/pkg/markers"
 	"sigs.k8s.io/controller-tools/pkg/version"
 )
 
-// FeatureGateMap represents a map of feature gate names to their enabled status.
-type FeatureGateMap map[string]bool
-
-// parseFeatureGates parses a feature gates string in the format "gate1=true,gate2=false"
-// and returns a FeatureGateMap. Supports comma-separated key=value pairs.
-// and returns a FeatureGateMap.
-func parseFeatureGates(featureGatesStr string) (FeatureGateMap, error) {
-	gates := make(FeatureGateMap)
-	if featureGatesStr == "" {
-		return gates, nil
-	}
-
-	pairs := strings.Split(featureGatesStr, ",")
-	for _, pair := range pairs {
-		parts := strings.Split(strings.TrimSpace(pair), "=")
-		if len(parts) != 2 {
-			return nil, fmt.Errorf("invalid feature gate format: %s (expected format: gate1=true,gate2=false)", pair)
-		}
-
-		name := strings.TrimSpace(parts[0])
-		valueStr := strings.TrimSpace(parts[1])
-
-		switch valueStr {
-		case "true":
-			gates[name] = true
-		case "false":
-			gates[name] = false
-		default:
-			return nil, fmt.Errorf("invalid feature gate value for %s: %s (must be 'true' or 'false')", name, valueStr)
-		}
-	}
-
-	return gates, nil
-}
-
-// isFeatureGateEnabled checks if a feature gate is enabled.
-func (fg FeatureGateMap) isEnabled(gateName string) bool {
-	enabled, exists := fg[gateName]
-	return exists && enabled
-}
-
 // The identifier for v1 CustomResourceDefinitions.
 const v1 = "v1"
 
@@ -175,7 +135,7 @@ func transformPreserveUnknownFields(value bool) func(map[string]interface{}) err
 }
 
 func (g Generator) Generate(ctx *genall.GenerationContext) error {
-	featureGates, err := parseFeatureGates(g.FeatureGates)
+	featureGates, err := featuregate.ParseFeatureGates(g.FeatureGates, true)
 	if err != nil {
 		return fmt.Errorf("invalid feature gates: %w", err)
 	}

pkg/crd/markers/validation.go

@@ -127,18 +127,14 @@ var ValidationIshMarkers = []*definitionWithHelp{
 		WithHelp(XPreserveUnknownFields{}.Help()),
 	must(markers.MakeDefinition("kubebuilder:pruning:PreserveUnknownFields", markers.DescribesType, XPreserveUnknownFields{})).
 		WithHelp(XPreserveUnknownFields{}.Help()),
+	
+	must(markers.MakeDefinition("kubebuilder:feature-gate", markers.DescribesField, FeatureGate(""))).
+		WithHelp(FeatureGate("").Help()),
 }
 
 func init() {
 	AllDefinitions = append(AllDefinitions, ValidationMarkers...)
 
-	// Add FeatureGate markers
-	featureGateMarkers := []*definitionWithHelp{
-		must(markers.MakeDefinition("kubebuilder:feature-gate", markers.DescribesField, FeatureGate(""))).WithHelp(FeatureGate("").Help()),
-		must(markers.MakeDefinition("kubebuilder:feature-gate", markers.DescribesType, FeatureGate(""))).WithHelp(FeatureGate("").Help()),
-	}
-	AllDefinitions = append(AllDefinitions, featureGateMarkers...)
-
 	for _, def := range ValidationMarkers {
 		typDef := def.clone()
 		typDef.Target = markers.DescribesType

pkg/crd/parser.go

@@ -21,6 +21,7 @@ import (
 
 	apiext "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
+	"sigs.k8s.io/controller-tools/pkg/featuregate"
 	"sigs.k8s.io/controller-tools/pkg/internal/crd"
 	"sigs.k8s.io/controller-tools/pkg/loader"
 	"sigs.k8s.io/controller-tools/pkg/markers"
@@ -94,7 +95,7 @@ type Parser struct {
 	GenerateEmbeddedObjectMeta bool
 
 	// FeatureGates specifies which feature gates are enabled for conditional field inclusion
-	FeatureGates FeatureGateMap
+	FeatureGates featuregate.FeatureGateMap
 }
 
 func (p *Parser) init() {

pkg/crd/schema.go

@@ -28,6 +28,7 @@ import (
 	apiext "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
 	crdmarkers "sigs.k8s.io/controller-tools/pkg/crd/markers"
+	"sigs.k8s.io/controller-tools/pkg/featuregate"
 	"sigs.k8s.io/controller-tools/pkg/loader"
 	"sigs.k8s.io/controller-tools/pkg/markers"
 )
@@ -72,12 +73,12 @@ type schemaContext struct {
 
 	allowDangerousTypes    bool
 	ignoreUnexportedFields bool
-	featureGates           FeatureGateMap
+	featureGates           featuregate.FeatureGateMap
 }
 
 // newSchemaContext constructs a new schemaContext for the given package and schema requester.
 // It must have type info added before use via ForInfo.
-func newSchemaContext(pkg *loader.Package, req schemaRequester, allowDangerousTypes, ignoreUnexportedFields bool, featureGates FeatureGateMap) *schemaContext {
+func newSchemaContext(pkg *loader.Package, req schemaRequester, allowDangerousTypes, ignoreUnexportedFields bool, featureGates featuregate.FeatureGateMap) *schemaContext {
 	pkg.NeedTypesInfo()
 	return &schemaContext{
 		pkg:                    pkg,
@@ -435,7 +436,7 @@ func structToSchema(ctx *schemaContext, structType *ast.StructType) *apiext.JSON
 		if featureGateMarker := field.Markers.Get("kubebuilder:feature-gate"); featureGateMarker != nil {
 			if featureGate, ok := featureGateMarker.(crdmarkers.FeatureGate); ok {
 				gateName := string(featureGate)
-				if !ctx.featureGates.isEnabled(gateName) {
+				if !ctx.featureGates.IsEnabled(gateName) {
 					// Skip this field as its feature gate is not enabled
 					continue
 				}

pkg/crd/schema_test.go

@@ -26,6 +26,7 @@ import (
 	pkgstest "golang.org/x/tools/go/packages/packagestest"
 	apiext "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
 	crdmarkers "sigs.k8s.io/controller-tools/pkg/crd/markers"
+	"sigs.k8s.io/controller-tools/pkg/featuregate"
 	testloader "sigs.k8s.io/controller-tools/pkg/loader/testutils"
 	"sigs.k8s.io/controller-tools/pkg/markers"
 )
@@ -64,7 +65,7 @@ func transform(t *testing.T, expr string) *apiext.JSONSchemaProps {
 	pkg.NeedTypesInfo()
 	failIfErrors(t, pkg.Errors)
 
-	schemaContext := newSchemaContext(pkg, nil, true, false, FeatureGateMap{}).ForInfo(&markers.TypeInfo{})
+	schemaContext := newSchemaContext(pkg, nil, true, false, featuregate.FeatureGateMap{}).ForInfo(&markers.TypeInfo{})
 	// yick: grab the only type definition
 	definedType := pkg.Syntax[0].Decls[0].(*ast.GenDecl).Specs[0].(*ast.TypeSpec).Type
 	result := typeToSchema(schemaContext, definedType)

pkg/featuregate/doc.go

@@ -22,18 +22,20 @@ This package addresses the code duplication that existed in CRD, RBAC, and Webho
 by providing a unified API for:
 
 - Parsing feature gate configurations from CLI parameters
-- Validating feature gate expressions with strict or legacy modes
+- Validating feature gate expressions with strict validation
 - Evaluating complex boolean expressions (AND, OR logic)
 - Managing known feature gates with a registry
 
 # Basic Usage
 
-The simplest way to use this package is with the legacy functions that maintain
-backward compatibility:
+The simplest way to use this package is:
 
-	gates := featuregate.ParseFeatureGatesLegacy("alpha=true,beta=false")
+	gates, err := featuregate.ParseFeatureGates("alpha=true,beta=false", false)
+	if err != nil {
+		// handle error
+	}
 	evaluator := featuregate.NewFeatureGateEvaluator(gates)
-	
+
 	if evaluator.EvaluateExpression("alpha|beta") {
 		// Include the feature
 	}
@@ -62,19 +64,19 @@ For new implementations requiring strict validation:
 	if err != nil {
 		// Handle parsing error
 	}
-	
+
 	err = registry.ValidateExpression("alpha|unknown")
 	if err != nil {
 		// Handle unknown gate error
 	}
 
-# Migration from Existing Code
+# Integration
 
-This package provides legacy functions that match the behavior of existing
-implementations in CRD, RBAC, and Webhook generators:
+This package provides functions that centralize the feature gate logic
+previously duplicated across CRD, RBAC, and Webhook generators:
 
-- ParseFeatureGatesLegacy() replaces individual parseFeatureGates() functions
-- ValidateFeatureGateExpressionLegacy() replaces individual validateFeatureGateExpression() functions
+- ParseFeatureGates() replaces individual parseFeatureGates() functions
+- ValidateFeatureGateExpression() replaces individual validateFeatureGateExpression() functions
 - FeatureGateEvaluator.EvaluateExpression() replaces individual shouldInclude*() functions
 
 The FeatureGateMap type is compatible with existing map[string]bool usage patterns.

pkg/featuregate/parser.go

@@ -65,10 +65,3 @@ func ParseFeatureGates(featureGates string, strict bool) (FeatureGateMap, error)
 
 	return gates, nil
 }
-
-// ParseFeatureGatesLegacy provides backward compatibility with the existing non-strict parsing behavior.
-// This is used by existing implementations that silently ignore invalid entries.
-func ParseFeatureGatesLegacy(featureGates string) FeatureGateMap {
-	gates, _ := ParseFeatureGates(featureGates, false)
-	return gates
-}

pkg/featuregate/parser_test.go

@@ -19,7 +19,7 @@ package featuregate
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/onsi/gomega"
 )
 
 func TestParseFeatureGates(t *testing.T) {
@@ -118,63 +118,18 @@ func TestParseFeatureGates(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
+			g := gomega.NewWithT(t)
 			result, err := ParseFeatureGates(tt.input, tt.strict)
 
 			if tt.expectError {
-				assert.Error(t, err)
+				g.Expect(err).To(gomega.HaveOccurred())
 				if tt.errorContains != "" {
-					assert.Contains(t, err.Error(), tt.errorContains)
+					g.Expect(err.Error()).To(gomega.ContainSubstring(tt.errorContains))
 				}
 			} else {
-				assert.NoError(t, err)
-				assert.Equal(t, tt.expected, result)
+				g.Expect(err).NotTo(gomega.HaveOccurred())
+				g.Expect(result).To(gomega.Equal(tt.expected))
 			}
 		})
 	}
 }
-
-func TestParseFeatureGatesLegacy(t *testing.T) {
-	tests := []struct {
-		name     string
-		input    string
-		expected FeatureGateMap
-	}{
-		{
-			name:     "empty string",
-			input:    "",
-			expected: FeatureGateMap{},
-		},
-		{
-			name:  "valid gates",
-			input: "alpha=true,beta=false",
-			expected: FeatureGateMap{
-				"alpha": true,
-				"beta":  false,
-			},
-		},
-		{
-			name:  "invalid format ignored",
-			input: "alpha=true,invalid,beta=false",
-			expected: FeatureGateMap{
-				"alpha": true,
-				"beta":  false,
-			},
-		},
-		{
-			name:  "invalid values default to false",
-			input: "alpha=true,beta=maybe,gamma=false",
-			expected: FeatureGateMap{
-				"alpha": true,
-				"beta":  false,
-				"gamma": false,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := ParseFeatureGatesLegacy(tt.input)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}

pkg/featuregate/registry.go

@@ -40,15 +40,6 @@ func NewRegistry(knownGates []string, strict bool) *Registry {
 	}
 }
 
-// NewLegacyRegistry creates a registry that maintains backward compatibility
-// with the existing behavior (no strict validation).
-func NewLegacyRegistry() *Registry {
-	return &Registry{
-		knownGates: sets.New[string](),
-		strict:     false,
-	}
-}
-
 // ParseAndValidate parses feature gates and validates expressions in one step.
 func (r *Registry) ParseAndValidate(featureGatesStr string, expression string) (FeatureGateMap, error) {
 	// Parse the feature gates