policy switch case, renaming policy, and dropping references

Author: krishagarwal278

docs/linters.md

@@ -567,29 +567,38 @@ By default, `references` is enabled and operates in standard mode, allowing 'Ref
 ```yaml
 lintersConfig:
   references:
-    policy: AllowRefAndRefs | ForbidRefAndRefs # Defaults to `AllowRefAndRefs`.
+    policy: PreferAbbreviatedReference | NoReferences # Defaults to `PreferAbbreviatedReference`.
 ```
 
-**Default behavior (policy: AllowRefAndRefs):**
-- Reports errors for fields containing 'Reference' or 'References' and suggests replacing with 'Ref' or 'Refs'
+**Default behavior (policy: PreferAbbreviatedReference):**
+- Reports errors for fields containing 'Reference' or 'References' and replaces with 'Ref' or 'Refs'
 - **Allows** fields containing 'Ref' or 'Refs' without reporting errors
 
-**Strict mode (policy: ForbidRefAndRefs):**
-- Reports errors for fields containing 'Reference' or 'References' anywhere and suggests replacing with 'Ref' or 'Refs'
-- **Also reports errors** for fields containing 'Ref' or 'Refs' anywhere (no automatic fix provided)
-- In this strict mode, the goal is to avoid all Ref/Refs/Reference/References in field names entirely
+**Strict mode (policy: NoReferences):**
+- Reports errors for any reference-related words in field names
+- Suggests removing 'Ref', 'Refs', 'Reference', or 'References' entirely from the beginning or end of field names
+- In this strict mode, the goal is to avoid all reference-related words in field names
 
 ### Fixes
 
-The `references` linter can automatically fix field names by replacing 'Reference' with 'Ref' and 'References' with 'Refs' anywhere in the field name.
-
-For example:
-- `NodeReference` → `NodeRef`
-- `ReferenceNode` → `RefNode`
-- `NodeReferenceConfig` → `NodeRefConfig`
-- `NodeReferences` → `NodeRefs`
-
-Note: In the `ForbidRefAndRefs` mode, the fixes are intermediate. As, the linter will still report errors on the resulting 'Ref'/'Refs' patterns, indicating they should be removed entirely
+The `references` linter can automatically fix field names based on the policy:
+
+**PreferAbbreviatedReference mode:**
+- Replaces 'Reference' with 'Ref' and 'References' with 'Refs' anywhere in the field name
+- Examples:
+  - `NodeReference` → `NodeRef`
+  - `ReferenceNode` → `RefNode`
+  - `NodeReferenceConfig` → `NodeRefConfig`
+  - `NodeReferences` → `NodeRefs`
+
+**NoReferences mode:**
+- Removes all reference-related words (Ref/Refs/Reference/References) from the beginning or end of field names
+- Examples:
+  - `RefNode` → `Node`
+  - `NodeRef` → `Node`
+  - `ReferenceName` → `Name`
+  - `ConfigReferences` → `Config`
+  - `ReferenceCount` → `Count`
 
 ## SSATags
 

pkg/analysis/references/analyzer.go

@@ -38,10 +38,10 @@ func newAnalyzer(cfg *Config) *analysis.Analyzer {
 		cfg = &Config{}
 	}
 
-	// Default to AllowRefAndRefs if no policy is specified
+	// Default to PreferAbbreviatedReference if no policy is specified
 	policy := cfg.Policy
 	if policy == "" {
-		policy = PolicyAllowRefAndRefs
+		policy = PolicyPreferAbbreviatedReference
 	}
 
 	// Build the namingconventions config based on the policy
@@ -75,36 +75,45 @@ func newAnalyzer(cfg *Config) *analysis.Analyzer {
 
 // buildConventions creates the naming conventions based on the policy.
 func buildConventions(policy Policy) []namingconventions.Convention {
-	// Base convention: Replace "Reference" or "References" with "Ref" or "Refs"
-	// Using a single regex with optional 's' capture group to handle both cases
-	conventions := []namingconventions.Convention{
-		{
-			Name:             "reference-to-ref",
-			ViolationMatcher: "(?i)reference(s?)",
-			Operation:        namingconventions.OperationReplacement,
-			Replacement:      "Ref$1",
-			Message:          "field names should use 'Ref' instead of 'Reference'",
-		},
-	}
-
-	// If policy is ForbidRefAndRefs, also flag Ref/Refs as problematic (no fix provided)
-	// This creates a two-step hint: fix Reference→Ref, but know that Ref also needs changing
-	if policy == PolicyForbidRefAndRefs {
-		conventions = append(conventions,
-			namingconventions.Convention{
-				Name:             "forbid-refs",
-				ViolationMatcher: "(?i)refs([^a-z]|$)",
-				Operation:        namingconventions.OperationInform,
-				Message:          "should not use 'Refs'",
+	switch policy {
+	case PolicyPreferAbbreviatedReference:
+		// Replace "Reference" or "References" with "Ref" or "Refs"
+		// Using a single regex with optional 's' capture group to handle both cases
+		return []namingconventions.Convention{
+			{
+				Name:             "reference-to-ref",
+				ViolationMatcher: "(?i)reference(s?)",
+				Operation:        namingconventions.OperationReplacement,
+				Replacement:      "Ref$1",
+				Message:          "field names should use 'Ref' instead of 'Reference'",
 			},
-			namingconventions.Convention{
-				Name:             "forbid-ref",
-				ViolationMatcher: "(?i)ref([^ers]|$)",
-				Operation:        namingconventions.OperationInform,
-				Message:          "should not use 'Ref'",
+		}
+
+	case PolicyNoReferences:
+		// Drop any reference-related words from field names
+		// Using a regex that matches Ref/Refs/Reference/References at start or end
+		// At start: matches when followed by an uppercase letter, preserving that letter
+		// At end: matches at the end of the field name
+		return []namingconventions.Convention{
+			{
+				Name:             "no-references",
+				ViolationMatcher: "^([Rr]ef(?:erence)?s?)([A-Z])|([Rr]ef(?:erence)?s?)$",
+				Operation:        namingconventions.OperationReplacement,
+				Replacement:      "$2",
+				Message:          "field names should not contain reference-related words",
 			},
-		)
+		}
+
+	default:
+		// Should not happen due to validation, but return PreferAbbreviatedReference conventions as fallback
+		return []namingconventions.Convention{
+			{
+				Name:             "reference-to-ref",
+				ViolationMatcher: "(?i)reference(s?)",
+				Operation:        namingconventions.OperationReplacement,
+				Replacement:      "Ref$1",
+				Message:          "field names should use 'Ref' instead of 'Reference'",
+			},
+		}
 	}
-
-	return conventions
 }

pkg/analysis/references/analyzer_test.go

@@ -22,11 +22,11 @@ import (
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/references"
 )
 
-func TestAllowRefAndRefs(t *testing.T) {
+func TestPreferAbbreviatedReference(t *testing.T) {
 	testdata := analysistest.TestData()
 
 	cfg := &references.Config{
-		Policy: references.PolicyAllowRefAndRefs,
+		Policy: references.PolicyPreferAbbreviatedReference,
 	}
 
 	analyzer, err := references.Initializer().Init(cfg)
@@ -40,24 +40,24 @@ func TestAllowRefAndRefs(t *testing.T) {
 func TestEmptyConfig(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	// Test with empty config - should default to AllowRefAndRefs behavior
+	// Test with empty config - should default to PreferAbbreviatedReference behavior
 	cfg := &references.Config{}
 
 	analyzer, err := references.Initializer().Init(cfg)
 	if err != nil {
 		t.Fatalf("initializing references linter: %v", err)
 	}
 
-	// With default config (empty Policy), it should default to AllowRefAndRefs behavior
+	// With default config (empty Policy), it should default to PreferAbbreviatedReference behavior
 	// So we test with folder 'a' which has the same expectations
 	analysistest.RunWithSuggestedFixes(t, testdata, analyzer, "a")
 }
 
-func TestForbidRefAndRefs(t *testing.T) {
+func TestNoReferences(t *testing.T) {
 	testdata := analysistest.TestData()
 
 	cfg := &references.Config{
-		Policy: references.PolicyForbidRefAndRefs,
+		Policy: references.PolicyNoReferences,
 	}
 
 	analyzer, err := references.Initializer().Init(cfg)

pkg/analysis/references/config.go

@@ -15,20 +15,22 @@ limitations under the License.
 */
 package references
 
-// policy defines the policy for handling Ref/Refs.
+// policy defines the policy for handling references in field names.
 type Policy string
 
 const (
-	// PolicyAllowRefAndRefs allows Ref/Refs in field names.
-	PolicyAllowRefAndRefs Policy = "AllowRefAndRefs"
-	// PolicyForbidRefAndRefs forbids Ref/Refs in field names.
-	PolicyForbidRefAndRefs Policy = "ForbidRefAndRefs"
+	// PolicyPreferAbbreviatedReference allows abbreviated forms (Ref/Refs) in field names.
+	// It suggests replacing Reference/References with Ref/Refs.
+	PolicyPreferAbbreviatedReference Policy = "PreferAbbreviatedReference"
+	// PolicyNoReferences forbids any reference-related words in field names.
+	// It suggests removing Ref/Refs/Reference/References entirely.
+	PolicyNoReferences Policy = "NoReferences"
 )
 
 // Config represents the configuration for the references linter.
 type Config struct {
-	// policy controls whether Ref/Refs are allowed or forbidden in field names.
-	// When set to AllowRefAndRefs (default), fields containing Ref/Refs are allowed.
-	// When set to ForbidRefAndRefs, fields containing Ref/Refs are flagged as errors.
+	// policy controls how reference-related words are handled in field names.
+	// When set to PreferAbbreviatedReference (default), Reference/References are replaced with Ref/Refs.
+	// When set to NoReferences, all reference-related words are suggested to be removed.
 	Policy Policy `json:"policy,omitempty"`
 }

pkg/analysis/references/initializer.go

@@ -51,12 +51,12 @@ func validateConfig(cfg *Config, fldPath *field.Path) field.ErrorList {
 
 	// Validate Policy enum if provided
 	switch cfg.Policy {
-	case PolicyAllowRefAndRefs, PolicyForbidRefAndRefs, "":
+	case PolicyPreferAbbreviatedReference, PolicyNoReferences, "":
 	default:
 		errs = append(errs, field.NotSupported(
 			fldPath.Child("policy"),
 			cfg.Policy,
-			[]string{string(PolicyAllowRefAndRefs), string(PolicyForbidRefAndRefs)},
+			[]string{string(PolicyPreferAbbreviatedReference), string(PolicyNoReferences)},
 		))
 	}
 	return errs

pkg/analysis/references/initializer_test.go

@@ -42,15 +42,15 @@ var _ = Describe("references initializer", func() {
 				Expect(errs).To(HaveLen(0), "No errors were expected")
 			}
 		},
-			Entry("With a valid references configuration with policy=ForbidRefAndRefs", testCase{
+			Entry("With a valid references configuration with policy=NoReferences", testCase{
 				config: &references.Config{
-					Policy: references.PolicyForbidRefAndRefs,
+					Policy: references.PolicyNoReferences,
 				},
 				expectedErr: "",
 			}),
-			Entry("With a valid references configuration with policy=AllowRefAndRefs", testCase{
+			Entry("With a valid references configuration with policy=PreferAbbreviatedReference", testCase{
 				config: &references.Config{
-					Policy: references.PolicyAllowRefAndRefs,
+					Policy: references.PolicyPreferAbbreviatedReference,
 				},
 				expectedErr: "",
 			}),
@@ -66,7 +66,7 @@ var _ = Describe("references initializer", func() {
 				config: &references.Config{
 					Policy: "InvalidPolicy",
 				},
-				expectedErr: "references.policy: Unsupported value: \"InvalidPolicy\": supported values: \"AllowRefAndRefs\", \"ForbidRefAndRefs\"",
+				expectedErr: "references.policy: Unsupported value: \"InvalidPolicy\": supported values: \"PreferAbbreviatedReference\", \"NoReferences\"",
 			}),
 		)
 	})

pkg/analysis/references/testdata/src/b/b.go

@@ -1,51 +1,40 @@
 package b
 
-// TestWithPolicyForbidRefAndRefs tests the linter with PolicyForbidRefAndRefs (strict mode)
-// In this mode, Reference/References AND Ref/Refs (at end) are flagged
-type TestWithPolicyForbidRefAndRefs struct {
+// TestWithPolicyNoReferences tests the linter with PolicyNoReferences (strict mode)
+// In this mode, all reference-related words (Reference/References/Ref/Refs) are removed
+type TestWithPolicyNoReferences struct {
 	// Fields ending with Reference should be flagged
-	NodeReference string `json:"nodeReference"` // want `naming convention "reference-to-ref": field NodeReference: field names should use 'Ref' instead of 'Reference'`
-
-	ConfigReference string `json:"configReference"` // want `naming convention "reference-to-ref": field ConfigReference: field names should use 'Ref' instead of 'Reference'`
+	NodeReference string `json:"nodeReference"` // want `naming convention "no-references": field NodeReference: field names should not contain reference-related words`
 
 	// Fields ending with References should be flagged
-	NodeReferences []string `json:"nodeReferences"` // want `naming convention "reference-to-ref": field NodeReferences: field names should use 'Ref' instead of 'Reference'`
-
-	ConfigReferences []string `json:"configReferences"` // want `naming convention "reference-to-ref": field ConfigReferences: field names should use 'Ref' instead of 'Reference'`
+	ConfigReferences []string `json:"configReferences"` // want `naming convention "no-references": field ConfigReferences: field names should not contain reference-related words`
 
 	// Fields with Reference at beginning should be flagged
-	ReferenceCount int `json:"referenceCount"` // want `naming convention "reference-to-ref": field ReferenceCount: field names should use 'Ref' instead of 'Reference'`
-
-	ReferenceData string `json:"referenceData"` // want `naming convention "reference-to-ref": field ReferenceData: field names should use 'Ref' instead of 'Reference'`
+	ReferenceCount int `json:"referenceCount"` // want `naming convention "no-references": field ReferenceCount: field names should not contain reference-related words`
 
 	// Fields with References at beginning should be flagged
-	ReferencesCount int `json:"referencesCount"` // want `naming convention "reference-to-ref": field ReferencesCount: field names should use 'Ref' instead of 'Reference'`
-
-	ReferencesData []string `json:"referencesData"` // want `naming convention "reference-to-ref": field ReferencesData: field names should use 'Ref' instead of 'Reference'`
-
-	// Fields with Reference in middle should be flagged
-	CrossReferenceID string `json:"crossReferenceID"` // want `naming convention "reference-to-ref": field CrossReferenceID: field names should use 'Ref' instead of 'Reference'`
-
-	// Fields with References in middle should be flagged
-	CrossReferencesMap map[string]string `json:"crossReferencesMap"` // want `naming convention "reference-to-ref": field CrossReferencesMap: field names should use 'Ref' instead of 'Reference'`
+	ReferencesData []string `json:"referencesData"` // want `naming convention "no-references": field ReferencesData: field names should not contain reference-related words`
 
-	// Fields ending with Ref should be FORBIDDEN in this mode
-	NodeRef string `json:"nodeRef"` // want `naming convention "forbid-ref": field NodeRef: should not use 'Ref'`
+	// Fields ending with Ref should be flagged
+	PodRef string `json:"podRef"` // want `naming convention "no-references": field PodRef: field names should not contain reference-related words`
 
-	ConfigRef string `json:"configRef"` // want `naming convention "forbid-ref": field ConfigRef: should not use 'Ref'`
+	// Fields ending with Refs should be flagged
+	ContainerRefs []string `json:"containerRefs"` // want `naming convention "no-references": field ContainerRefs: field names should not contain reference-related words`
 
-	// Fields ending with Refs should be FORBIDDEN in this mode
-	NodeRefs []string `json:"nodeRefs"` // want `naming convention "forbid-refs": field NodeRefs: should not use 'Refs'`
+	// Fields starting with Ref should be flagged
+	RefStatus string `json:"refStatus"` // want `naming convention "no-references": field RefStatus: field names should not contain reference-related words`
 
-	ConfigRefs []string `json:"configRefs"` // want `naming convention "forbid-refs": field ConfigRefs: should not use 'Refs'`
+	// Fields starting with Refs should be flagged
+	RefsTotal int `json:"refsTotal"` // want `naming convention "no-references": field RefsTotal: field names should not contain reference-related words`
 
-	// Normal fields should not be flagged (no Reference/References/Ref/Refs)
+	// Normal fields should not be flagged
 	Name string `json:"name"`
 
 	Namespace string `json:"namespace"`
 
-	// Edge cases - Preference contains "reference" and will be flagged
-	PreferenceType string `json:"preferenceType"` // want `naming convention "reference-to-ref": field PreferenceType: field names should use 'Ref' instead of 'Reference'`
+	// Edge cases - "erence" in the middle of a word is not flagged (only start/end boundaries)
+	PreferenceType string `json:"preferenceType"`
 
-	Preferences map[string]string `json:"preferences,omitempty"` // want `naming convention "reference-to-ref": field Preferences: field names should use 'Ref' instead of 'Reference'`
+	// But "Preferences" ending with 's' after "erence" IS flagged since it ends with "ences"
+	Preferences map[string]string `json:"preferences,omitempty"` // want `naming convention "no-references": field Preferences: field names should not contain reference-related words`
 }