Switch lintersconfig to be untyped map

Author: JoelSpeed

docs/linters.md

@@ -113,7 +113,7 @@ The `jsontags` linter checks the tag name against the regex `"^[a-z][a-z0-9]*(?:
 
 ```yaml
 lintersConfig:
-  jsonTags:
+  jsontags:
     jsonTagRegex: "^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$" # Provide a custom regex, which the json tag must match.
 ```
 
@@ -178,7 +178,7 @@ In this case, the `omitempty` policy can be set to `Ignore`, and the linter will
 
 ```yaml
 lintersConfig:
-  optionalFields:
+  optionalfields:
     pointers:
       preference: Always | WhenRequired # Whether to always require pointers, or only when required. Defaults to `Always`.
       policy: SuggestFix | Warn # The policy for pointers in optional fields. Defaults to `SuggestFix`.
@@ -216,7 +216,7 @@ The `optionalorrequired` linter also checks for the presence of optional or requ
 
 ```yaml
 lintersConfig:
-  optionalOrRequired:
+  optionalorrequired:
     preferredOptionalMarker: optional | kubebuilder:validation:Optional # The preferred optional marker to use, fixes will suggest to use this marker. Defaults to `optional`.
     preferredRequiredMarker: required | kubebuilder:validation:Required # The preferred required marker to use, fixes will suggest to use this marker. Defaults to `required`.
 ```
@@ -236,7 +236,7 @@ and not having an `omitempty` value in their `json` tag.
 
 ```yaml
 lintersConfig:
-  requiredFields:
+  requiredfields:
     pointerPolicy: Warn | SuggestFix # The policy for pointers in required fields. Defaults to `SuggestFix`.
 ```
 
@@ -326,7 +326,7 @@ Because this linter has no way of determining which marker definition was intend
 It can configured to include a set of custom markers in the analysis by setting:
 ```yaml
 lintersConfig:
-  uniqueMarkers:
+  uniquemarkers:
     customMarkers:
       - identifier: custom:SomeCustomMarker
         attributes:

pkg/analysis/commentstart/initializer.go

@@ -18,7 +18,6 @@ package commentstart
 import (
 	"golang.org/x/tools/go/analysis"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/initializer"
-	"sigs.k8s.io/kube-api-linter/pkg/config"
 )
 
 // Initializer returns the AnalyzerInitializer for this
@@ -32,6 +31,6 @@ func Initializer() initializer.AnalyzerInitializer {
 }
 
 // Init returns the intialized Analyzer.
-func initAnalyzer(cfg config.LintersConfig) (*analysis.Analyzer, error) {
+func initAnalyzer(_ any) (*analysis.Analyzer, error) {
 	return Analyzer, nil
 }

pkg/analysis/conditions/analyzer.go

@@ -28,7 +28,6 @@ import (
 	kalerrors "sigs.k8s.io/kube-api-linter/pkg/analysis/errors"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/helpers/extractjsontags"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/helpers/markers"
-	"sigs.k8s.io/kube-api-linter/pkg/config"
 )
 
 const (
@@ -63,14 +62,14 @@ func init() {
 }
 
 type analyzer struct {
-	isFirstField     config.ConditionsFirstField
-	useProtobuf      config.ConditionsUseProtobuf
-	usePatchStrategy config.ConditionsUsePatchStrategy
+	isFirstField     ConditionsFirstField
+	useProtobuf      ConditionsUseProtobuf
+	usePatchStrategy ConditionsUsePatchStrategy
 }
 
 // newAnalyzer creates a new analyzer.
-func newAnalyzer(cfg config.ConditionsConfig) *analysis.Analyzer {
-	defaultConfig(&cfg)
+func newAnalyzer(cfg *ConditionsConfig) *analysis.Analyzer {
+	defaultConfig(cfg)
 
 	a := &analyzer{
 		isFirstField:     cfg.IsFirstField,
@@ -136,12 +135,12 @@ func (a *analyzer) checkField(pass *analysis.Pass, index int, field *ast.Field,
 	checkFieldMarkers(pass, field, fieldMarkers, a.usePatchStrategy)
 	a.checkFieldTags(pass, index, field)
 
-	if a.isFirstField == config.ConditionsFirstFieldWarn && index != 0 {
+	if a.isFirstField == ConditionsFirstFieldWarn && index != 0 {
 		pass.Reportf(field.Pos(), "Conditions field must be the first field in the struct")
 	}
 }
 
-func checkFieldMarkers(pass *analysis.Pass, field *ast.Field, fieldMarkers markers.MarkerSet, usePatchStrategy config.ConditionsUsePatchStrategy) {
+func checkFieldMarkers(pass *analysis.Pass, field *ast.Field, fieldMarkers markers.MarkerSet, usePatchStrategy ConditionsUsePatchStrategy) {
 	missingMarkers := []string{}
 	additionalMarkers := []markers.Marker{}
 
@@ -170,22 +169,22 @@ func checkFieldMarkers(pass *analysis.Pass, field *ast.Field, fieldMarkers marke
 	}
 }
 
-func checkPatchStrategyMarkers(fieldMarkers markers.MarkerSet, usePatchStrategy config.ConditionsUsePatchStrategy) ([]string, []markers.Marker) {
+func checkPatchStrategyMarkers(fieldMarkers markers.MarkerSet, usePatchStrategy ConditionsUsePatchStrategy) ([]string, []markers.Marker) {
 	missingMarkers := []string{}
 	additionalMarkers := []markers.Marker{}
 
 	switch usePatchStrategy {
-	case config.ConditionsUsePatchStrategySuggestFix, config.ConditionsUsePatchStrategyWarn:
+	case ConditionsUsePatchStrategySuggestFix, ConditionsUsePatchStrategyWarn:
 		if !fieldMarkers.HasWithValue(patchStrategyMerge) {
 			missingMarkers = append(missingMarkers, patchStrategyMerge)
 		}
 
 		if !fieldMarkers.HasWithValue(patchMergeKeyType) {
 			missingMarkers = append(missingMarkers, patchMergeKeyType)
 		}
-	case config.ConditionsUsePatchStrategyIgnore:
+	case ConditionsUsePatchStrategyIgnore:
 		// If it's there, we don't care.
-	case config.ConditionsUsePatchStrategyForbid:
+	case ConditionsUsePatchStrategyForbid:
 		if fieldMarkers.HasWithValue(patchStrategyMerge) {
 			additionalMarkers = append(additionalMarkers, fieldMarkers[patchStrategy]...)
 		}
@@ -200,11 +199,11 @@ func checkPatchStrategyMarkers(fieldMarkers markers.MarkerSet, usePatchStrategy
 	return missingMarkers, additionalMarkers
 }
 
-func reportMissingMarkers(pass *analysis.Pass, field *ast.Field, missingMarkers []string, usePatchStrategy config.ConditionsUsePatchStrategy) {
+func reportMissingMarkers(pass *analysis.Pass, field *ast.Field, missingMarkers []string, usePatchStrategy ConditionsUsePatchStrategy) {
 	suggestedFixes := []analysis.SuggestedFix{}
 
 	// If patch strategy is warn, and the only markers in the list are patchStrategy and patchMergeKeyType, we don't need to suggest a fix.
-	if usePatchStrategy != config.ConditionsUsePatchStrategyWarn || slices.ContainsFunc[[]string, string](missingMarkers, func(marker string) bool {
+	if usePatchStrategy != ConditionsUsePatchStrategyWarn || slices.ContainsFunc[[]string, string](missingMarkers, func(marker string) bool {
 		switch marker {
 		case patchStrategyMerge, patchMergeKeyType:
 			return false
@@ -324,14 +323,14 @@ func (a *analyzer) checkFieldTags(pass *analysis.Pass, index int, field *ast.Fie
 	}
 }
 
-func getExpectedTag(usePatchStrategy config.ConditionsUsePatchStrategy, useProtobuf config.ConditionsUseProtobuf, isFirstField config.ConditionsFirstField, index int) string {
+func getExpectedTag(usePatchStrategy ConditionsUsePatchStrategy, useProtobuf ConditionsUseProtobuf, isFirstField ConditionsFirstField, index int) string {
 	expectedTag := fmt.Sprintf("`%s", expectedJSONTag)
 
-	if usePatchStrategy == config.ConditionsUsePatchStrategySuggestFix || usePatchStrategy == config.ConditionsUsePatchStrategyWarn {
+	if usePatchStrategy == ConditionsUsePatchStrategySuggestFix || usePatchStrategy == ConditionsUsePatchStrategyWarn {
 		expectedTag += fmt.Sprintf(" %s", expectedPatchTag)
 	}
 
-	if useProtobuf == config.ConditionsUseProtobufSuggestFix || useProtobuf == config.ConditionsUseProtobufWarn {
+	if useProtobuf == ConditionsUseProtobufSuggestFix || useProtobuf == ConditionsUseProtobufWarn {
 		expectedTag += fmt.Sprintf(" %s", getExpectedProtobufTag(isFirstField, index))
 	}
 
@@ -340,46 +339,46 @@ func getExpectedTag(usePatchStrategy config.ConditionsUsePatchStrategy, useProto
 	return expectedTag
 }
 
-func getExpectedProtobufTag(isFirstField config.ConditionsFirstField, index int) string {
+func getExpectedProtobufTag(isFirstField ConditionsFirstField, index int) string {
 	i := 1
-	if isFirstField == config.ConditionsFirstFieldIgnore {
+	if isFirstField == ConditionsFirstFieldIgnore {
 		i = index + 1
 	}
 
 	return fmt.Sprintf(expectedProtobufTag, i)
 }
 
-func tagIsAsExpected(tag string, usePatchStrategy config.ConditionsUsePatchStrategy, useProtobuf config.ConditionsUseProtobuf, isFirstField config.ConditionsFirstField, index int) (bool, bool) {
+func tagIsAsExpected(tag string, usePatchStrategy ConditionsUsePatchStrategy, useProtobuf ConditionsUseProtobuf, isFirstField ConditionsFirstField, index int) (bool, bool) {
 	patchTagCorrect, patchShouldSuggestFix := patchStrategyTagIsAsExpected(tag, usePatchStrategy)
 	protoTagCorrect, protoShouldSuggestFix := protobufTagIsAsExpected(tag, useProtobuf, isFirstField, index)
 
 	return patchTagCorrect && protoTagCorrect, patchShouldSuggestFix || protoShouldSuggestFix
 }
 
-func patchStrategyTagIsAsExpected(tag string, usePatchStrategy config.ConditionsUsePatchStrategy) (bool, bool) {
+func patchStrategyTagIsAsExpected(tag string, usePatchStrategy ConditionsUsePatchStrategy) (bool, bool) {
 	switch usePatchStrategy {
-	case config.ConditionsUsePatchStrategySuggestFix:
+	case ConditionsUsePatchStrategySuggestFix:
 		return strings.Contains(tag, expectedPatchTag), true
-	case config.ConditionsUsePatchStrategyWarn:
+	case ConditionsUsePatchStrategyWarn:
 		return strings.Contains(tag, expectedPatchTag), false
-	case config.ConditionsUsePatchStrategyIgnore:
+	case ConditionsUsePatchStrategyIgnore:
 		return true, false
-	case config.ConditionsUsePatchStrategyForbid:
+	case ConditionsUsePatchStrategyForbid:
 		return !strings.Contains(tag, expectedPatchTag), true
 	default:
 		panic("unexpected usePatchStrategy value")
 	}
 }
 
-func protobufTagIsAsExpected(tag string, useProtobuf config.ConditionsUseProtobuf, isFirstField config.ConditionsFirstField, index int) (bool, bool) {
+func protobufTagIsAsExpected(tag string, useProtobuf ConditionsUseProtobuf, isFirstField ConditionsFirstField, index int) (bool, bool) {
 	switch useProtobuf {
-	case config.ConditionsUseProtobufSuggestFix:
+	case ConditionsUseProtobufSuggestFix:
 		return strings.Contains(tag, getExpectedProtobufTag(isFirstField, index)), true
-	case config.ConditionsUseProtobufWarn:
+	case ConditionsUseProtobufWarn:
 		return strings.Contains(tag, getExpectedProtobufTag(isFirstField, index)), false
-	case config.ConditionsUseProtobufIgnore:
+	case ConditionsUseProtobufIgnore:
 		return true, false
-	case config.ConditionsUseProtobufForbid:
+	case ConditionsUseProtobufForbid:
 		return !strings.Contains(tag, getExpectedProtobufTag(isFirstField, index)), true
 	default:
 		panic("unexpected useProtobuf value")
@@ -429,16 +428,16 @@ func isSliceMetaV1Condition(field *ast.Field) bool {
 	return true
 }
 
-func defaultConfig(cfg *config.ConditionsConfig) {
+func defaultConfig(cfg *ConditionsConfig) {
 	if cfg.IsFirstField == "" {
-		cfg.IsFirstField = config.ConditionsFirstFieldWarn
+		cfg.IsFirstField = ConditionsFirstFieldWarn
 	}
 
 	if cfg.UseProtobuf == "" {
-		cfg.UseProtobuf = config.ConditionsUseProtobufSuggestFix
+		cfg.UseProtobuf = ConditionsUseProtobufSuggestFix
 	}
 
 	if cfg.UsePatchStrategy == "" {
-		cfg.UsePatchStrategy = config.ConditionsUsePatchStrategySuggestFix
+		cfg.UsePatchStrategy = ConditionsUsePatchStrategySuggestFix
 	}
 }

pkg/analysis/conditions/analyzer_test.go

@@ -20,13 +20,12 @@ import (
 
 	"golang.org/x/tools/go/analysis/analysistest"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/conditions"
-	"sigs.k8s.io/kube-api-linter/pkg/config"
 )
 
 func TestDefaultConfiguration(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	a, err := conditions.Initializer().Init(config.LintersConfig{})
+	a, err := conditions.Initializer().Init(&conditions.ConditionsConfig{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -37,10 +36,8 @@ func TestDefaultConfiguration(t *testing.T) {
 func TestNotFieldFirst(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	a, err := conditions.Initializer().Init(config.LintersConfig{
-		Conditions: config.ConditionsConfig{
-			IsFirstField: config.ConditionsFirstFieldIgnore,
-		},
+	a, err := conditions.Initializer().Init(&conditions.ConditionsConfig{
+		IsFirstField: conditions.ConditionsFirstFieldIgnore,
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -52,10 +49,8 @@ func TestNotFieldFirst(t *testing.T) {
 func TestIgnoreProtobuf(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	a, err := conditions.Initializer().Init(config.LintersConfig{
-		Conditions: config.ConditionsConfig{
-			UseProtobuf: config.ConditionsUseProtobufIgnore,
-		},
+	a, err := conditions.Initializer().Init(&conditions.ConditionsConfig{
+		UseProtobuf: conditions.ConditionsUseProtobufIgnore,
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -67,10 +62,8 @@ func TestIgnoreProtobuf(t *testing.T) {
 func TestForbidProtobuf(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	a, err := conditions.Initializer().Init(config.LintersConfig{
-		Conditions: config.ConditionsConfig{
-			UseProtobuf: config.ConditionsUseProtobufForbid,
-		},
+	a, err := conditions.Initializer().Init(&conditions.ConditionsConfig{
+		UseProtobuf: conditions.ConditionsUseProtobufForbid,
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -82,10 +75,8 @@ func TestForbidProtobuf(t *testing.T) {
 func TestIgnorePatchStrategy(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	a, err := conditions.Initializer().Init(config.LintersConfig{
-		Conditions: config.ConditionsConfig{
-			UsePatchStrategy: config.ConditionsUsePatchStrategyIgnore,
-		},
+	a, err := conditions.Initializer().Init(&conditions.ConditionsConfig{
+		UsePatchStrategy: conditions.ConditionsUsePatchStrategyIgnore,
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -97,10 +88,8 @@ func TestIgnorePatchStrategy(t *testing.T) {
 func TestForbidPatchStrategy(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	a, err := conditions.Initializer().Init(config.LintersConfig{
-		Conditions: config.ConditionsConfig{
-			UsePatchStrategy: config.ConditionsUsePatchStrategyForbid,
-		},
+	a, err := conditions.Initializer().Init(&conditions.ConditionsConfig{
+		UsePatchStrategy: conditions.ConditionsUsePatchStrategyForbid,
 	})
 	if err != nil {
 		t.Fatal(err)