Move validations directly into analyzer packages

JoelSpeed · JoelSpeed · commit ab9f31e6c7eb · 2025-07-09T14:26:07.000+01:00
diff --git a/pkg/analysis/commentstart/initializer.go b/pkg/analysis/commentstart/initializer.go
@@ -39,6 +39,11 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return Analyzer, nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return false
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	return true
diff --git a/pkg/analysis/conditions/initializer.go b/pkg/analysis/conditions/initializer.go
@@ -16,7 +16,10 @@ limitations under the License.
 package conditions
 
 import (
+	"fmt"
+
 	"golang.org/x/tools/go/analysis"
+	"k8s.io/apimachinery/pkg/util/validation/field"
 	"sigs.k8s.io/kube-api-linter/pkg/config"
 )
 
@@ -39,6 +42,41 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return newAnalyzer(cfg.Conditions), nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return true
+}
+
+// ValidateConfig implements validation of the conditions linter config.
+func (initializer) ValidateConfig(cfg any, fldPath *field.Path) field.ErrorList {
+	cc, ok := cfg.(config.ConditionsConfig)
+	if !ok {
+		return field.ErrorList{field.InternalError(fldPath, fmt.Errorf("incorrect type for passed configuration: %T", cfg))}
+	}
+
+	fieldErrors := field.ErrorList{}
+
+	switch cc.IsFirstField {
+	case "", config.ConditionsFirstFieldWarn, config.ConditionsFirstFieldIgnore:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("isFirstField"), cc.IsFirstField, fmt.Sprintf("invalid value, must be one of %q, %q or omitted", config.ConditionsFirstFieldWarn, config.ConditionsFirstFieldIgnore)))
+	}
+
+	switch cc.UseProtobuf {
+	case "", config.ConditionsUseProtobufSuggestFix, config.ConditionsUseProtobufWarn, config.ConditionsUseProtobufIgnore, config.ConditionsUseProtobufForbid:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("useProtobuf"), cc.UseProtobuf, fmt.Sprintf("invalid value, must be one of %q, %q, %q, %q or omitted", config.ConditionsUseProtobufSuggestFix, config.ConditionsUseProtobufWarn, config.ConditionsUseProtobufIgnore, config.ConditionsUseProtobufForbid)))
+	}
+
+	switch cc.UsePatchStrategy {
+	case "", config.ConditionsUsePatchStrategySuggestFix, config.ConditionsUsePatchStrategyWarn, config.ConditionsUsePatchStrategyIgnore, config.ConditionsUsePatchStrategyForbid:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("usePatchStrategy"), cc.UsePatchStrategy, fmt.Sprintf("invalid value, must be one of %q, %q, %q, %q or omitted", config.ConditionsUsePatchStrategySuggestFix, config.ConditionsUsePatchStrategyWarn, config.ConditionsUsePatchStrategyIgnore, config.ConditionsUsePatchStrategyForbid)))
+	}
+
+	return fieldErrors
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	return true
diff --git a/pkg/analysis/duplicatemarkers/initializer.go b/pkg/analysis/duplicatemarkers/initializer.go
@@ -39,6 +39,11 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return Analyzer, nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return false
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	// Duplicated markers are a sign of bad code, and should be avoided.
diff --git a/pkg/analysis/integers/initializer.go b/pkg/analysis/integers/initializer.go
@@ -39,6 +39,11 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return Analyzer, nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return false
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	return true
diff --git a/pkg/analysis/jsontags/initializer.go b/pkg/analysis/jsontags/initializer.go
@@ -16,7 +16,11 @@ limitations under the License.
 package jsontags
 
 import (
+	"fmt"
+	"regexp"
+
 	"golang.org/x/tools/go/analysis"
+	"k8s.io/apimachinery/pkg/util/validation/field"
 	"sigs.k8s.io/kube-api-linter/pkg/config"
 )
 
@@ -39,6 +43,29 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return newAnalyzer(cfg.JSONTags)
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return true
+}
+
+// validateJSONTagsConfig is used to validate the configuration in the config.JSONTagsConfig struct.
+func (initializer) ValidateConfig(cfg any, fldPath *field.Path) field.ErrorList {
+	jtc, ok := cfg.(config.JSONTagsConfig)
+	if !ok {
+		return field.ErrorList{field.InternalError(fldPath, fmt.Errorf("incorrect type for passed configuration: %T", cfg))}
+	}
+
+	fieldErrors := field.ErrorList{}
+
+	if jtc.JSONTagRegex != "" {
+		if _, err := regexp.Compile(jtc.JSONTagRegex); err != nil {
+			fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("jsonTagRegex"), jtc.JSONTagRegex, fmt.Sprintf("invalid regex: %v", err)))
+		}
+	}
+
+	return fieldErrors
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	return true
diff --git a/pkg/analysis/maxlength/initializer.go b/pkg/analysis/maxlength/initializer.go
@@ -39,6 +39,11 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return Analyzer, nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return false
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	return false // For now, CRD only, and so not on by default.
diff --git a/pkg/analysis/nobools/initializer.go b/pkg/analysis/nobools/initializer.go
@@ -39,6 +39,11 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return Analyzer, nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return false
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	// Bools avoidance in the Kube conventions is not a must.
diff --git a/pkg/analysis/nofloats/initializer.go b/pkg/analysis/nofloats/initializer.go
@@ -39,6 +39,11 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return Analyzer, nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return false
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	// Floats avoidance in the Kube conventions is a must for spec fields.
diff --git a/pkg/analysis/nomaps/initializer.go b/pkg/analysis/nomaps/initializer.go
@@ -16,7 +16,10 @@ limitations under the License.
 package nomaps
 
 import (
+	"fmt"
+
 	"golang.org/x/tools/go/analysis"
+	"k8s.io/apimachinery/pkg/util/validation/field"
 	"sigs.k8s.io/kube-api-linter/pkg/config"
 )
 
@@ -39,6 +42,30 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return newAnalyzer(cfg.NoMaps), nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return true
+}
+
+// ValidateConfig is used to validate the configuration in the config.NoMapsConfig struct.
+func (initializer) ValidateConfig(cfg any, fldPath *field.Path) field.ErrorList {
+	nmc, ok := cfg.(config.NoMapsConfig)
+	if !ok {
+		return field.ErrorList{field.InternalError(fldPath, fmt.Errorf("incorrect type for passed configuration: %T", cfg))}
+	}
+
+	fieldErrors := field.ErrorList{}
+
+	switch nmc.Policy {
+	case config.NoMapsEnforce, config.NoMapsAllowStringToStringMaps, config.NoMapsIgnore, "":
+		// Valid values
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("policy"), nmc.Policy, fmt.Sprintf("invalid value, must be one of %q, %q, %q or omitted", config.NoMapsEnforce, config.NoMapsAllowStringToStringMaps, config.NoMapsIgnore)))
+	}
+
+	return fieldErrors
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	return true
diff --git a/pkg/analysis/nophase/initializer.go b/pkg/analysis/nophase/initializer.go
@@ -39,6 +39,11 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return Analyzer, nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return false
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	return true
diff --git a/pkg/analysis/optionalfields/initializer.go b/pkg/analysis/optionalfields/initializer.go
@@ -16,7 +16,10 @@ limitations under the License.
 package optionalfields
 
 import (
+	"fmt"
+
 	"golang.org/x/tools/go/analysis"
+	"k8s.io/apimachinery/pkg/util/validation/field"
 	"sigs.k8s.io/kube-api-linter/pkg/config"
 )
 
@@ -39,7 +42,59 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return newAnalyzer(cfg.OptionalFields), nil
 }
 
+// ValidateConfig validates the configuration in the config.OptionalFieldsConfig struct.
+func (initializer) ValidateConfig(cfg any, fldPath *field.Path) field.ErrorList {
+	ofc, ok := cfg.(config.OptionalFieldsConfig)
+	if !ok {
+		return field.ErrorList{field.InternalError(fldPath, fmt.Errorf("incorrect type for passed configuration: %T", cfg))}
+	}
+
+	fieldErrors := field.ErrorList{}
+
+	fieldErrors = append(fieldErrors, validateOptionFieldsPointers(ofc.Pointers, fldPath.Child("pointers"))...)
+	fieldErrors = append(fieldErrors, validateOptionFieldsOmitEmpty(ofc.OmitEmpty, fldPath.Child("omitEmpty"))...)
+
+	return fieldErrors
+}
+
+// validateOptionFieldsPointers is used to validate the configuration in the config.OptionalFieldsPointers struct.
+func validateOptionFieldsPointers(opc config.OptionalFieldsPointers, fldPath *field.Path) field.ErrorList {
+	fieldErrors := field.ErrorList{}
+
+	switch opc.Preference {
+	case "", config.OptionalFieldsPointerPreferenceAlways, config.OptionalFieldsPointerPreferenceWhenRequired:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("preference"), opc.Preference, fmt.Sprintf("invalid value, must be one of %q, %q or omitted", config.OptionalFieldsPointerPreferenceAlways, config.OptionalFieldsPointerPreferenceWhenRequired)))
+	}
+
+	switch opc.Policy {
+	case "", config.OptionalFieldsPointerPolicySuggestFix, config.OptionalFieldsPointerPolicyWarn:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("policy"), opc.Policy, fmt.Sprintf("invalid value, must be one of %q, %q or omitted", config.OptionalFieldsPointerPolicySuggestFix, config.OptionalFieldsPointerPolicyWarn)))
+	}
+
+	return fieldErrors
+}
+
+// validateOptionFieldsOmitEmpty is used to validate the configuration in the config.OptionalFieldsOmitEmpty struct.
+func validateOptionFieldsOmitEmpty(oec config.OptionalFieldsOmitEmpty, fldPath *field.Path) field.ErrorList {
+	fieldErrors := field.ErrorList{}
+
+	switch oec.Policy {
+	case "", config.OptionalFieldsOmitEmptyPolicyIgnore, config.OptionalFieldsOmitEmptyPolicyWarn, config.OptionalFieldsOmitEmptyPolicySuggestFix:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("policy"), oec.Policy, fmt.Sprintf("invalid value, must be one of %q, %q, %q or omitted", config.OptionalFieldsOmitEmptyPolicyIgnore, config.OptionalFieldsOmitEmptyPolicyWarn, config.OptionalFieldsOmitEmptyPolicySuggestFix)))
+	}
+
+	return fieldErrors
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	return true
 }
+
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return true
+}
diff --git a/pkg/analysis/optionalorrequired/initializer.go b/pkg/analysis/optionalorrequired/initializer.go
@@ -16,8 +16,12 @@ limitations under the License.
 package optionalorrequired
 
 import (
+	"fmt"
+
 	"golang.org/x/tools/go/analysis"
+	"k8s.io/apimachinery/pkg/util/validation/field"
 	"sigs.k8s.io/kube-api-linter/pkg/config"
+	"sigs.k8s.io/kube-api-linter/pkg/markers"
 )
 
 // Initializer returns the AnalyzerInitializer for this
@@ -39,6 +43,35 @@ func (initializer) Init(cfg config.LintersConfig) (*analysis.Analyzer, error) {
 	return newAnalyzer(cfg.OptionalOrRequired), nil
 }
 
+// IsConfigurable determines whether or not the Analyzer provides configuration options.
+func (initializer) IsConfigurable() bool {
+	return true
+}
+
+// ValidateConfig is used to validate the configuration in the config.OptionalOrRequiredConfig struct.
+func (initializer) ValidateConfig(cfg any, fldPath *field.Path) field.ErrorList {
+	oorc, ok := cfg.(config.OptionalOrRequiredConfig)
+	if !ok {
+		return field.ErrorList{field.InternalError(fldPath, fmt.Errorf("incorrect type for passed configuration: %T", cfg))}
+	}
+
+	fieldErrors := field.ErrorList{}
+
+	switch oorc.PreferredOptionalMarker {
+	case "", markers.OptionalMarker, markers.KubebuilderOptionalMarker:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("preferredOptionalMarker"), oorc.PreferredOptionalMarker, fmt.Sprintf("invalid value, must be one of %q, %q or omitted", markers.OptionalMarker, markers.KubebuilderOptionalMarker)))
+	}
+
+	switch oorc.PreferredRequiredMarker {
+	case "", markers.RequiredMarker, markers.KubebuilderRequiredMarker:
+	default:
+		fieldErrors = append(fieldErrors, field.Invalid(fldPath.Child("preferredRequiredMarker"), oorc.PreferredRequiredMarker, fmt.Sprintf("invalid value, must be one of %q, %q or omitted", markers.RequiredMarker, markers.KubebuilderRequiredMarker)))
+	}
+
+	return fieldErrors
+}
+
 // Default determines whether this Analyzer is on by default, or not.
 func (initializer) Default() bool {
 	return true
diff --git a/pkg/analysis/registry.go b/pkg/analysis/registry.go
@@ -40,6 +40,7 @@ import (
 
 	kerrors "k8s.io/apimachinery/pkg/util/errors"
 	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/apimachinery/pkg/util/validation/field"
 )
 
 // AnalyzerInitializer is used to intializer analyzers.
@@ -51,11 +52,25 @@ type AnalyzerInitializer interface {
 	// It will be passed the complete LintersConfig and is expected to rely only on its own configuration.
 	Init(config.LintersConfig) (*analysis.Analyzer, error)
 
+	// IsConfigurable determines whether or not the initializer expects to be provided a config.
+	// When true, the initializer should also match the ConfigurableAnalyzerInitializer interface.
+	IsConfigurable() bool
+
 	// Default determines whether the inializer intializes an analyzer that should be
 	// on by default, or not.
 	Default() bool
 }
 
+// ConfigurableAnalyzerInitializer is an analyzer initializer that also has a configuration.
+// This means it can validate its config.
+type ConfigurableAnalyzerInitializer interface {
+	AnalyzerInitializer
+
+	// ValidateConfig will be called during the config validation phase and is used to validate
+	// the provided config for the linter.
+	ValidateConfig(any, *field.Path) field.ErrorList
+}
+
 // Registry is used to fetch and initialize analyzers.
 type Registry interface {
 	// DefaultLinters returns the names of linters that are enabled by default.
@@ -136,6 +151,13 @@ func (r *registry) InitializeLinters(cfg config.Linters, lintersCfg config.Linte
 	allDisabled := disabled.Len() == 1 && disabled.Has(config.Wildcard)
 
 	for _, initializer := range r.initializers {
+		if initializer.IsConfigurable() {
+			_, ok := initializer.(ConfigurableAnalyzerInitializer)
+			if !ok {
+				panic(fmt.Sprintf("Analyzer %s claims to be configurable but does not implement the ConfigurableAnalyzerInitializer interface", initializer.Name()))
+			}
+		}
+
 		if !disabled.Has(initializer.Name()) && (allEnabled || enabled.Has(initializer.Name()) || !allDisabled && initializer.Default()) {
 			a, err := initializer.Init(lintersCfg)
 			if err != nil {
diff --git a/pkg/analysis/requiredfields/initializer.go b/pkg/analysis/requiredfields/initializer.go
diff --git a/pkg/analysis/ssatags/initializer.go b/pkg/analysis/ssatags/initializer.go
diff --git a/pkg/analysis/statusoptional/initializer.go b/pkg/analysis/statusoptional/initializer.go
diff --git a/pkg/analysis/statussubresource/initializer.go b/pkg/analysis/statussubresource/initializer.go
diff --git a/pkg/analysis/uniquemarkers/initializer.go b/pkg/analysis/uniquemarkers/initializer.go
diff --git a/pkg/validation/linters_config.go b/pkg/validation/linters_config.go
