Remove legacy backward compatibility functions

Since feature gates are a new feature, no need for legacy functions:
- Remove ParseFeatureGatesLegacy(), ValidateFeatureGateExpressionLegacy(), NewLegacyRegistry()
- Update all usages to standard functions with non-strict validation
- Clean up documentation and tests

Author: sami-wazery

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

@@ -132,49 +132,3 @@ func TestParseFeatureGates(t *testing.T) {
 		})
 	}
 }
-
-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

pkg/featuregate/registry_test.go

@@ -34,13 +34,6 @@ func TestNewRegistry(t *testing.T) {
 	assert.False(t, registry.IsKnownGate("unknown"))
 }
 
-func TestNewLegacyRegistry(t *testing.T) {
-	registry := NewLegacyRegistry()
-
-	assert.False(t, registry.strict)
-	assert.Equal(t, 0, registry.knownGates.Len())
-}
-
 func TestRegistry_ParseAndValidate(t *testing.T) {
 	registry := NewRegistry([]string{"alpha", "beta"}, true)
 

pkg/featuregate/validator.go

@@ -60,12 +60,6 @@ func ValidateFeatureGateExpression(expr string, knownGates sets.Set[string], str
 	return nil
 }
 
-// ValidateFeatureGateExpressionLegacy provides backward compatibility with the existing validation behavior.
-// This does not perform strict validation of gate names.
-func ValidateFeatureGateExpressionLegacy(expr string) error {
-	return ValidateFeatureGateExpression(expr, nil, false)
-}
-
 // isValidCharacter checks if a character is valid in a feature gate expression.
 func isValidCharacter(char rune) bool {
 	return (char >= 'a' && char <= 'z') ||

pkg/featuregate/validator_test.go

@@ -166,63 +166,6 @@ func TestValidateFeatureGateExpression(t *testing.T) {
 	}
 }
 
-func TestValidateFeatureGateExpressionLegacy(t *testing.T) {
-	tests := []struct {
-		name          string
-		expr          string
-		expectError   bool
-		errorContains string
-	}{
-		{
-			name: "empty expression",
-			expr: "",
-		},
-		{
-			name: "simple gate name",
-			expr: "alpha",
-		},
-		{
-			name: "OR expression",
-			expr: "alpha|beta",
-		},
-		{
-			name: "AND expression",
-			expr: "alpha&beta",
-		},
-		{
-			name:          "mixed operators",
-			expr:          "alpha&beta|gamma",
-			expectError:   true,
-			errorContains: "cannot mix '&' and '|' operators",
-		},
-		{
-			name:          "invalid character",
-			expr:          "alpha@beta",
-			expectError:   true,
-			errorContains: "invalid character '@'",
-		},
-		{
-			name: "unknown gate - no error in legacy mode",
-			expr: "unknown_gate",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := ValidateFeatureGateExpressionLegacy(tt.expr)
-
-			if tt.expectError {
-				assert.Error(t, err)
-				if tt.errorContains != "" {
-					assert.Contains(t, err.Error(), tt.errorContains)
-				}
-			} else {
-				assert.NoError(t, err)
-			}
-		})
-	}
-}
-
 func TestExtractGateNames(t *testing.T) {
 	tests := []struct {
 		name     string

pkg/rbac/advanced_feature_gates_test.go

@@ -129,7 +129,7 @@ func TestFeatureGateValidation(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			err := featuregate.ValidateFeatureGateExpressionLegacy(tt.expression)
+			err := featuregate.ValidateFeatureGateExpression(tt.expression, nil, false)
 			if tt.shouldError {
 				if err == nil {
 					t.Errorf("Expected error for expression %s, but got none", tt.expression)

pkg/rbac/parser.go

@@ -27,8 +27,8 @@ import (
 	"sort"
 	"strings"
 
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	rbacv1 "k8s.io/api/rbac/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
 	"sigs.k8s.io/controller-tools/pkg/featuregate"
 	"sigs.k8s.io/controller-tools/pkg/genall"
@@ -197,9 +197,12 @@ func (Generator) RegisterMarkers(into *markers.Registry) error {
 // The order of the objs in the returned slice is stable and determined by their namespaces.
 func GenerateRoles(ctx *genall.GenerationContext, roleName string, featureGates string) ([]interface{}, error) {
 	// Parse feature gates using the centralized package
-	enabledGates := featuregate.ParseFeatureGatesLegacy(featureGates)
+	enabledGates, err := featuregate.ParseFeatureGates(featureGates, false)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse feature gates: %w", err)
+	}
 	evaluator := featuregate.NewFeatureGateEvaluator(enabledGates)
-	
+
 	rulesByNSResource := make(map[string][]*Rule)
 	for _, root := range ctx.Roots {
 		markerSet, err := markers.PackageMarkers(ctx.Collector, root)
@@ -212,7 +215,7 @@ func GenerateRoles(ctx *genall.GenerationContext, roleName string, featureGates
 			rule := markerValue.(Rule)
 
 			// Validate feature gate expression syntax using centralized package
-			if err := featuregate.ValidateFeatureGateExpressionLegacy(rule.FeatureGate); err != nil {
+			if err := featuregate.ValidateFeatureGateExpression(rule.FeatureGate, nil, false); err != nil {
 				return nil, fmt.Errorf("invalid feature gate expression in RBAC rule: %w", err)
 			}