feat: finalize feature gate implementation with latest changes

Author: wazery

cmd/controller-gen/workflow.go

@@ -232,7 +232,7 @@ func runGenerationForCombination(featureGates string, outputPath string, paths [
 	fmt.Printf("  Generating: %s -> %s\n", featureGates, outputPath)
 
 	// Parse feature gates to validate them
-	_, err := featuregate.ParseFeatureGates(featureGates, false)
+	_, err := featuregate.ParseFeatureGates(featureGates)
 	if err != nil {
 		return fmt.Errorf("invalid feature gates %s: %w", featureGates, err)
 	}

pkg/crd/gen.go

@@ -135,7 +135,7 @@ func transformPreserveUnknownFields(value bool) func(map[string]interface{}) err
 }
 
 func (g Generator) Generate(ctx *genall.GenerationContext) error {
-	featureGates, err := featuregate.ParseFeatureGates(g.FeatureGates, true)
+	featureGates, err := featuregate.ParseFeatureGates(g.FeatureGates)
 	if err != nil {
 		return fmt.Errorf("invalid feature gates: %w", err)
 	}
@@ -336,8 +336,8 @@ func FindKubeKinds(parser *Parser, metav1Pkg *loader.Package, featureGates featu
 
 		// Check type-level feature gate marker
 		if featureGateMarker := info.Markers.Get("kubebuilder:featuregate"); featureGateMarker != nil {
-			if typeFeatureGate, ok := featureGateMarker.(crdmarkers.TypeFeatureGate); ok {
-				gateName := string(typeFeatureGate)
+			if featureGate, ok := featureGateMarker.(crdmarkers.FeatureGate); ok {
+				gateName := string(featureGate)
 				// Create evaluator to handle complex expressions (OR/AND logic)
 				evaluator := featuregate.NewFeatureGateEvaluator(featureGates)
 				if !evaluator.EvaluateExpression(gateName) {

pkg/crd/markers/crd.go

@@ -57,9 +57,6 @@ var CRDMarkers = []*definitionWithHelp{
 
 	must(markers.MakeDefinition("kubebuilder:selectablefield", markers.DescribesType, SelectableField{})).
 		WithHelp(SelectableField{}.Help()),
-
-	must(markers.MakeDefinition("kubebuilder:featuregate", markers.DescribesType, TypeFeatureGate(""))).
-		WithHelp(TypeFeatureGate("").Help()),
 }
 
 // TODO: categories and singular used to be annotations types
@@ -422,22 +419,3 @@ func (s SelectableField) ApplyToCRD(crd *apiext.CustomResourceDefinitionSpec, ve
 
 	return nil
 }
-
-// +controllertools:marker:generateHelp:category="CRD feature gates"
-
-// TypeFeatureGate marks an entire CRD type to be conditionally generated based on feature gate enablement.
-// Types marked with +kubebuilder:featuregate will only be included in generated CRDs
-// when the specified feature gate is enabled via the crd:featureGates parameter.
-//
-// Single gate format: +kubebuilder:featuregate=alpha
-// OR expression: +kubebuilder:featuregate=alpha|beta
-// AND expression: +kubebuilder:featuregate=alpha&beta
-// Complex expression: +kubebuilder:featuregate=(alpha&beta)|gamma
-type TypeFeatureGate string
-
-// ApplyToCRD does nothing for type feature gates - they are processed by the generator
-// to conditionally include/exclude entire CRDs during generation.
-func (TypeFeatureGate) ApplyToCRD(crd *apiext.CustomResourceDefinitionSpec, version string) error {
-	// Type feature gates are handled during CRD discovery/generation, not during CRD spec modification
-	return nil
-}

pkg/crd/markers/validation.go

@@ -139,11 +139,11 @@ var ValidationIshMarkers = []*definitionWithHelp{
 	must(markers.MakeAnyTypeDefinition("kubebuilder:title", markers.DescribesType, Title{})).
 		WithHelp(Title{}.Help()),
 
+	// Feature gate markers for both fields and types (separate registrations)
 	must(markers.MakeDefinition("kubebuilder:featuregate", markers.DescribesField, FeatureGate(""))).
 		WithHelp(FeatureGate("").Help()),
-
-	must(markers.MakeDefinition("kubebuilder:validation:featureGate", markers.DescribesField, FeatureGateValidation{})).
-		WithHelp(markers.SimpleHelp("CRD validation feature gates", "applies validation rules conditionally based on feature gate enablement.")),
+	must(markers.MakeDefinition("kubebuilder:featuregate", markers.DescribesType, FeatureGate(""))).
+		WithHelp(FeatureGate("").Help()),
 }
 
 func init() {
@@ -756,44 +756,3 @@ func fieldsToOneOfCelRuleStr(fields []string) string {
 }
 
 // +controllertools:marker:generateHelp:category="CRD validation feature gates"
-
-// FeatureGateValidation marks a validation constraint to be conditionally applied based on feature gate enablement.
-// This allows validation rules to be enabled/disabled based on feature gates.
-// The validation parameter accepts the same values as standard kubebuilder:validation markers.
-//
-// Examples:
-//   - +kubebuilder:validation:featureGate=alpha,rule="Maximum=100"
-//   - +kubebuilder:validation:featureGate=alpha|beta,rule="MinLength=5"
-//   - +kubebuilder:validation:featureGate=(alpha&beta)|gamma,rule="Pattern=^[a-z]+$"
-type FeatureGateValidation struct {
-	// FeatureGate specifies the feature gate expression that must be satisfied
-	// for this validation rule to be applied. Supports complex expressions with
-	// AND (&), OR (|) operators and parentheses for precedence.
-	FeatureGate string `marker:"featureGate"`
-
-	// Rule specifies the validation rule to apply when the feature gate is enabled.
-	// This should be a valid validation marker rule (e.g., "Maximum=100", "MinLength=5").
-	Rule string `marker:"rule"`
-}
-
-// ApplyToSchema applies the validation rule to the schema if the feature gate is enabled.
-func (f FeatureGateValidation) ApplyToSchema(schema *apiext.JSONSchemaProps) error {
-	// This will be called by the schema generation with access to the context
-	// The actual feature gate evaluation will be handled by the caller
-	return fmt.Errorf("FeatureGateValidation cannot be applied directly - use feature gate context")
-}
-
-// SupportsFeatureGate indicates this marker supports feature gates
-func (f FeatureGateValidation) SupportsFeatureGate() bool {
-	return true
-}
-
-// GetFeatureGate returns the feature gate expression
-func (f FeatureGateValidation) GetFeatureGate() string {
-	return f.FeatureGate
-}
-
-// GetValidationRule returns the validation rule to apply
-func (f FeatureGateValidation) GetValidationRule() string {
-	return f.Rule
-}

pkg/crd/markers/zz_generated.markerhelp.go

@@ -30,7 +30,7 @@ by providing a unified API for:
 
 The simplest way to use this package is:
 
-	gates, err := featuregate.ParseFeatureGates("alpha=true,beta=false", false)
+	gates, err := featuregate.ParseFeatureGates("alpha=true,beta=false")
 	if err != nil {
 		// handle error
 	}

pkg/featuregate/doc.go

@@ -69,23 +69,13 @@ func (fge *FeatureGateEvaluator) evaluateOrExpression(expr string) bool {
 	return false
 }
 
-// hasAndOperator checks if the expression contains AND operators.
-func hasAndOperator(expr string) bool {
-	return strings.Contains(expr, "&")
-}
-
-// hasOrOperator checks if the expression contains OR operators.
-func hasOrOperator(expr string) bool {
-	return strings.Contains(expr, "|")
-}
-
-// evaluateComplexExpression evaluates complex feature gate expressions with parentheses.
-// Supports expressions like "(alpha&beta)|gamma" with proper precedence.
-func (fge *FeatureGateEvaluator) evaluateComplexExpression(expr string) bool {
+// evaluateSimpleExpression evaluates feature gate expressions with support for parentheses,
+// OR operations (lower precedence), and AND operations (higher precedence).
+func (fge *FeatureGateEvaluator) evaluateSimpleExpression(expr string) bool {
 	// Remove all spaces for easier parsing
 	expr = strings.ReplaceAll(expr, " ", "")
 
-	// Handle the expression recursively by evaluating parentheses first
+	// Handle parentheses by evaluating them first (highest precedence)
 	for strings.Contains(expr, "(") {
 		// Find the innermost parentheses
 		start := -1
@@ -108,13 +98,6 @@ func (fge *FeatureGateEvaluator) evaluateComplexExpression(expr string) bool {
 		}
 	}
 
-	// Now evaluate the remaining expression (which should be simple)
-	return fge.evaluateSimpleExpression(expr)
-}
-
-// evaluateSimpleExpression evaluates a simple expression without parentheses.
-// Handles OR operations which have lower precedence than AND operations.
-func (fge *FeatureGateEvaluator) evaluateSimpleExpression(expr string) bool {
 	// Handle special boolean values from parenthetical evaluation
 	if expr == boolTrueStr {
 		return true

pkg/featuregate/evaluator.go

@@ -167,6 +167,19 @@ var _ = Describe("FeatureGate Evaluator", func() {
 				Expect(evaluator.EvaluateExpression("(alpha|gamma)&beta")).To(BeFalse())
 			})
 
+			It("should handle mixed operators without parentheses using precedence (AND before OR)", func() {
+				// alpha&gamma|beta = (alpha&gamma)|beta = (true&true)|false = true|false = true
+				Expect(evaluator.EvaluateExpression("alpha&gamma|beta")).To(BeTrue())
+				// alpha&beta|delta = (alpha&beta)|delta = (true&false)|false = false|false = false
+				Expect(evaluator.EvaluateExpression("alpha&beta|delta")).To(BeFalse())
+				// beta&delta|alpha = (beta&delta)|alpha = (false&false)|true = false|true = true
+				Expect(evaluator.EvaluateExpression("beta&delta|alpha")).To(BeTrue())
+				// More complex: alpha|beta&gamma = alpha|(beta&gamma) = true|(false&true) = true|false = true
+				Expect(evaluator.EvaluateExpression("alpha|beta&gamma")).To(BeTrue())
+				// More complex: beta|alpha&delta = beta|(alpha&delta) = false|(true&false) = false|false = false
+				Expect(evaluator.EvaluateExpression("beta|alpha&delta")).To(BeFalse())
+			})
+
 			It("should handle nested parentheses", func() {
 				// ((alpha&gamma)|beta)&delta = ((true&true)|false)&false = (true|false)&false = true&false = false
 				Expect(evaluator.EvaluateExpression("((alpha&gamma)|beta)&delta")).To(BeFalse())

pkg/featuregate/evaluator_test.go

@@ -24,12 +24,12 @@ import (
 // ParseFeatureGates parses a comma-separated feature gate string into a FeatureGateMap.
 // Format: "gate1=true,gate2=false,gate3=true"
 //
-// With strict validation enabled, this function will return an error for:
+// This function will return an error for:
 // - Invalid format (missing = or wrong number of parts)
 // - Invalid values (anything other than "true" or "false")
 //
-// Returns a FeatureGateMap and an error if parsing fails with strict validation.
-func ParseFeatureGates(featureGates string, strict bool) (FeatureGateMap, error) {
+// Returns a FeatureGateMap and an error if parsing fails.
+func ParseFeatureGates(featureGates string) (FeatureGateMap, error) {
 	gates := make(FeatureGateMap)
 	if featureGates == "" {
 		return gates, nil
@@ -39,11 +39,7 @@ func ParseFeatureGates(featureGates string, strict bool) (FeatureGateMap, error)
 	for _, pair := range pairs {
 		parts := strings.Split(strings.TrimSpace(pair), "=")
 		if len(parts) != 2 {
-			if strict {
-				return nil, fmt.Errorf("invalid feature gate format: %s (expected format: gate1=true,gate2=false)", pair)
-			}
-			// In non-strict mode, skip invalid entries
-			continue
+			return nil, fmt.Errorf("invalid feature gate format: %s (expected format: gate1=true,gate2=false)", pair)
 		}
 
 		gateName := strings.TrimSpace(parts[0])
@@ -55,11 +51,7 @@ func ParseFeatureGates(featureGates string, strict bool) (FeatureGateMap, error)
 		case "false":
 			gates[gateName] = false
 		default:
-			if strict {
-				return nil, fmt.Errorf("invalid feature gate value for %s: %s (must be 'true' or 'false')", gateName, gateValue)
-			}
-			// In non-strict mode, treat invalid values as false
-			gates[gateName] = false
+			return nil, fmt.Errorf("invalid feature gate value for %s: %s (must be 'true' or 'false')", gateName, gateValue)
 		}
 	}
 

pkg/featuregate/parser.go

@@ -26,88 +26,61 @@ func TestParseFeatureGates(t *testing.T) {
 	tests := []struct {
 		name          string
 		input         string
-		strict        bool
 		expected      FeatureGateMap
 		expectError   bool
 		errorContains string
 	}{
 		{
 			name:     "empty string",
 			input:    "",
-			strict:   true,
 			expected: FeatureGateMap{},
 		},
 		{
-			name:   "single gate enabled",
-			input:  "alpha=true",
-			strict: true,
+			name:  "single gate enabled",
+			input: "alpha=true",
 			expected: FeatureGateMap{
 				"alpha": true,
 			},
 		},
 		{
-			name:   "single gate disabled",
-			input:  "alpha=false",
-			strict: true,
+			name:  "single gate disabled",
+			input: "alpha=false",
 			expected: FeatureGateMap{
 				"alpha": false,
 			},
 		},
 		{
-			name:   "multiple gates",
-			input:  "alpha=true,beta=false,gamma=true",
-			strict: true,
+			name:  "multiple gates",
+			input: "alpha=true,beta=false,gamma=true",
 			expected: FeatureGateMap{
 				"alpha": true,
 				"beta":  false,
 				"gamma": true,
 			},
 		},
 		{
-			name:   "gates with spaces",
-			input:  " alpha = true , beta = false ",
-			strict: true,
+			name:  "gates with spaces",
+			input: " alpha = true , beta = false ",
 			expected: FeatureGateMap{
 				"alpha": true,
 				"beta":  false,
 			},
 		},
 		{
-			name:          "invalid format strict mode",
+			name:          "invalid format",
 			input:         "alpha=true,invalid,beta=false",
-			strict:        true,
 			expectError:   true,
 			errorContains: "invalid feature gate format",
 		},
 		{
-			name:   "invalid format non-strict mode",
-			input:  "alpha=true,invalid,beta=false",
-			strict: false,
-			expected: FeatureGateMap{
-				"alpha": true,
-				"beta":  false,
-			},
-		},
-		{
-			name:          "invalid value strict mode",
+			name:          "invalid value",
 			input:         "alpha=true,beta=maybe",
-			strict:        true,
 			expectError:   true,
 			errorContains: "invalid feature gate value",
 		},
 		{
-			name:   "invalid value non-strict mode",
-			input:  "alpha=true,beta=maybe",
-			strict: false,
-			expected: FeatureGateMap{
-				"alpha": true,
-				"beta":  false, // Invalid values default to false
-			},
-		},
-		{
-			name:   "complex gate names",
-			input:  "v1beta1=true,my-feature=false,under_score=true",
-			strict: true,
+			name:  "complex gate names",
+			input: "v1beta1=true,my-feature=false,under_score=true",
 			expected: FeatureGateMap{
 				"v1beta1":     true,
 				"my-feature":  false,
@@ -119,7 +92,7 @@ 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)
+			result, err := ParseFeatureGates(tt.input)
 
 			if tt.expectError {
 				g.Expect(err).To(gomega.HaveOccurred())