Renamed references to noreferences, updated docs, and regex

Author: krishagarwal278

docs/linters.md

@@ -18,7 +18,7 @@
 - [Notimestamp](#notimestamp) - Prevents usage of 'TimeStamp' fields
 - [OptionalFields](#optionalfields) - Validates optional field conventions
 - [OptionalOrRequired](#optionalorrequired) - Ensures fields are explicitly marked as optional or required
-- [References](#references) - Ensures field names use Ref/Refs instead of Reference/References
+- [NoReferences](#noreferences) - Ensures field names use Ref/Refs instead of Reference/References
 - [RequiredFields](#requiredfields) - Validates required field conventions
 - [SSATags](#ssatags) - Ensures proper Server-Side Apply (SSA) tags on array fields
 - [StatusOptional](#statusoptional) - Ensures status fields are marked as optional
@@ -556,17 +556,17 @@ If you prefer not to suggest fixes for pointers in required fields, you can chan
 If you prefer not to suggest fixes for `omitempty` in required fields, you can change the `omitempty.policy` to `Warn` or `Ignore`.
 If you prefer not to suggest fixes for `omitzero` in required fields, you can change the `omitzero.policy` to `Warn` and also not to consider `omitzero` policy at all, it can be set to `Forbid`.
 
-## References
+## NoReferences
 
-The `references` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.
+The `noreferences` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.
 
-By default, `references` is enabled and operates in standard mode, allowing 'Ref'/'Refs' but prohibiting 'Reference'/'References' in field names.
+By default, `noreferences` is enabled and operates in standard mode, allowing 'Ref'/'Refs' but prohibiting 'Reference'/'References' in field names.
 
 ### Configuration
 
 ```yaml
 lintersConfig:
-  references:
+  noreferences:
     policy: PreferAbbreviatedReference | NoReferences # Defaults to `PreferAbbreviatedReference`.
 ```
 
@@ -581,24 +581,27 @@ lintersConfig:
 
 ### Fixes
 
-The `references` linter can automatically fix field names based on the policy:
+The `noreferences` 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
+- Replaces 'Reference' with 'Ref' and 'References' with 'Refs' at the start or end of field names
+- This avoids false positives for words like "Preference" where "eference" appears in the middle
 - Examples:
-  - `NodeReference` → `NodeRef`
-  - `ReferenceNode` → `RefNode`
-  - `NodeReferenceConfig` → `NodeRefConfig`
-  - `NodeReferences` → `NodeRefs`
+  - `NodeReference` → `NodeRef` (end)
+  - `ReferenceNode` → `RefNode` (start)
+  - `NodeReferences` → `NodeRefs` (end)
+  - `ReferencesCount` → `RefsCount` (start)
+  - `PreferenceType` → no change (middle - not flagged)
 
 **NoReferences mode:**
 - Removes all reference-related words (Ref/Refs/Reference/References) from the beginning or end of field names
+- Like PreferAbbreviatedReference, this only matches at word boundaries to avoid false positives
 - Examples:
-  - `RefNode` → `Node`
-  - `NodeRef` → `Node`
-  - `ReferenceName` → `Name`
-  - `ConfigReferences` → `Config`
-  - `ReferenceCount` → `Count`
+  - `RefNode` → `Node` (start)
+  - `NodeRef` → `Node` (end)
+  - `ReferenceName` → `Name` (start)
+  - `ConfigReferences` → `Config` (end)
+  - `ReferenceCount` → `Count` (start)
 
 ## SSATags
 

pkg/analysis/references/analyzer.go renamed to pkg/analysis/noreferences/analyzer.go

@@ -13,7 +13,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-package references
+package noreferences
 
 import (
 	"errors"
@@ -26,13 +26,13 @@ import (
 )
 
 const (
-	name = "references"
+	name = "noreferences"
 	doc  = "Enforces that fields use Ref/Refs and not Reference/References"
 )
 
 var errUnexpectedInitializerType = errors.New("expected namingconventions.Initializer() to be of type initializer.ConfigurableAnalyzerInitializer, but was not")
 
-// newAnalyzer creates a new analyzer for the references linter that is a wrapper around the namingconventions linter.
+// newAnalyzer creates a new analyzer for the noreferences linter that is a wrapper around the namingconventions linter.
 func newAnalyzer(cfg *Config) *analysis.Analyzer {
 	if cfg == nil {
 		cfg = &Config{}
@@ -56,15 +56,15 @@ func newAnalyzer(cfg *Config) *analysis.Analyzer {
 	}
 
 	// Validate generated namingconventions configuration
-	errs := configInit.ValidateConfig(ncConfig, field.NewPath("references"))
+	errs := configInit.ValidateConfig(ncConfig, field.NewPath("noreferences"))
 	if err := errs.ToAggregate(); err != nil {
-		panic(fmt.Errorf("references linter has an invalid namingconventions configuration: %w", err))
+		panic(fmt.Errorf("noreferences linter has an invalid namingconventions configuration: %w", err))
 	}
 
 	// Initialize the wrapped analyzer
 	analyzer, err := configInit.Init(ncConfig)
 	if err != nil {
-		panic(fmt.Errorf("references linter encountered an error initializing wrapped namingconventions analyzer: %w", err))
+		panic(fmt.Errorf("noreferences linter encountered an error initializing wrapped namingconventions analyzer: %w", err))
 	}
 
 	analyzer.Name = name
@@ -78,42 +78,36 @@ func buildConventions(policy Policy) []namingconventions.Convention {
 	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
+		// At start: [Rr]eference(s?) matches Reference/References (case insensitive R)
+		// At end: Reference(s?)$ matches Reference/References (capital R only to avoid "*preference")
 		return []namingconventions.Convention{
 			{
 				Name:             "reference-to-ref",
-				ViolationMatcher: "(?i)reference(s?)",
+				ViolationMatcher: "^[Rr]eference(s?)|Reference(s?)$",
 				Operation:        namingconventions.OperationReplacement,
-				Replacement:      "Ref$1",
+				Replacement:      "Ref$1$2",
 				Message:          "field names should use 'Ref' instead of 'Reference'",
 			},
 		}
 
 	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
+		// At start: matches [Rr]ef(erence)?s? followed by uppercase letter, preserving that letter ($3)
+		// At end: matches Ref(erence)?s? at end (capital R to avoid "*preference")
+		// When at start, $3 captures and preserves the next uppercase letter
+		// When at end, $3 is empty, effectively dropping the text
 		return []namingconventions.Convention{
 			{
 				Name:             "no-references",
-				ViolationMatcher: "^([Rr]ef(?:erence)?s?)([A-Z])|([Rr]ef(?:erence)?s?)$",
+				ViolationMatcher: "^[Rr]ef(erence)?(s?)([A-Z])|Ref(erence)?(s?)$",
 				Operation:        namingconventions.OperationReplacement,
-				Replacement:      "$2",
+				Replacement:      "$3",
 				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'",
-			},
-		}
+		// Should not happen due to validation
+		panic(fmt.Errorf("invalid policy: %s", policy))
 	}
 }

pkg/analysis/references/analyzer_test.go renamed to pkg/analysis/noreferences/analyzer_test.go

@@ -13,25 +13,25 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-package references_test
+package noreferences_test
 
 import (
 	"testing"
 
 	"golang.org/x/tools/go/analysis/analysistest"
-	"sigs.k8s.io/kube-api-linter/pkg/analysis/references"
+	"sigs.k8s.io/kube-api-linter/pkg/analysis/noreferences"
 )
 
 func TestPreferAbbreviatedReference(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	cfg := &references.Config{
-		Policy: references.PolicyPreferAbbreviatedReference,
+	cfg := &noreferences.Config{
+		Policy: noreferences.PolicyPreferAbbreviatedReference,
 	}
 
-	analyzer, err := references.Initializer().Init(cfg)
+	analyzer, err := noreferences.Initializer().Init(cfg)
 	if err != nil {
-		t.Fatalf("initializing references linter: %v", err)
+		t.Fatalf("initializing noreferences linter: %v", err)
 	}
 
 	analysistest.RunWithSuggestedFixes(t, testdata, analyzer, "a")
@@ -41,11 +41,11 @@ func TestEmptyConfig(t *testing.T) {
 	testdata := analysistest.TestData()
 
 	// Test with empty config - should default to PreferAbbreviatedReference behavior
-	cfg := &references.Config{}
+	cfg := &noreferences.Config{}
 
-	analyzer, err := references.Initializer().Init(cfg)
+	analyzer, err := noreferences.Initializer().Init(cfg)
 	if err != nil {
-		t.Fatalf("initializing references linter: %v", err)
+		t.Fatalf("initializing noreferences linter: %v", err)
 	}
 
 	// With default config (empty Policy), it should default to PreferAbbreviatedReference behavior
@@ -56,13 +56,13 @@ func TestEmptyConfig(t *testing.T) {
 func TestNoReferences(t *testing.T) {
 	testdata := analysistest.TestData()
 
-	cfg := &references.Config{
-		Policy: references.PolicyNoReferences,
+	cfg := &noreferences.Config{
+		Policy: noreferences.PolicyNoReferences,
 	}
 
-	analyzer, err := references.Initializer().Init(cfg)
+	analyzer, err := noreferences.Initializer().Init(cfg)
 	if err != nil {
-		t.Fatalf("initializing references linter: %v", err)
+		t.Fatalf("initializing noreferences linter: %v", err)
 	}
 
 	analysistest.RunWithSuggestedFixes(t, testdata, analyzer, "b")

pkg/analysis/references/config.go renamed to pkg/analysis/noreferences/config.go

@@ -13,7 +13,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-package references
+package noreferences
 
 // policy defines the policy for handling references in field names.
 type Policy string
@@ -27,7 +27,7 @@ const (
 	PolicyNoReferences Policy = "NoReferences"
 )
 
-// Config represents the configuration for the references linter.
+// Config represents the configuration for the noreferences linter.
 type Config struct {
 	// policy controls how reference-related words are handled in field names.
 	// When set to PreferAbbreviatedReference (default), Reference/References are replaced with Ref/Refs.

pkg/analysis/references/doc.go renamed to pkg/analysis/noreferences/doc.go

@@ -15,29 +15,25 @@ limitations under the License.
 */
 
 /*
-The `references` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.
-By default, `references` is enabled and enforces this naming convention.
+The `noreferences` linter ensures that field names use 'Ref'/'Refs' instead of 'Reference'/'References'.
+By default, `noreferences` is enabled and enforces this naming convention.
 The linter checks that 'Reference' anywhere in field names (beginning, middle, or end) is replaced with 'Ref'.
 Similarly, 'References' anywhere in field names is replaced with 'Refs'.
 
 Example configuration:
-**Default behavior (allow Ref/Refs in field names):**
-```yaml
-lintersConfig:
+Default behavior (allow Ref/Refs in field names):
 
-	references:
-	  policy: AllowRefAndRefs
+	lintersConfig:
+	  noreferences:
+	    policy: PreferAbbreviatedReference
 
-```
-**Strict mode (forbid Ref/Refs in field names):**
-```yaml
-lintersConfig:
+Strict mode (forbid Ref/Refs in field names):
 
-	references:
-	  policy: ForbidRefAndRefs
+	lintersConfig:
+	  noreferences:
+	    policy: NoReferences
 
-```
-When `policy` is set to `AllowRefAndRefs` (the default), fields containing 'Ref' or 'Refs' are allowed.
-The policy can be set to `ForbidRefAndRefs` to also report errors for 'Ref' or 'Refs' in field names.
+When `policy` is set to `PreferAbbreviatedReference` (the default), fields containing 'Ref' or 'Refs' are allowed.
+The policy can be set to `NoReferences` to also report errors for 'Ref' or 'Refs' in field names.
 */
-package references
+package noreferences

pkg/analysis/references/initializer.go renamed to pkg/analysis/noreferences/initializer.go

@@ -13,7 +13,7 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-package references
+package noreferences
 
 import (
 	"golang.org/x/tools/go/analysis"
@@ -41,7 +41,7 @@ func initAnalyzer(cfg *Config) (*analysis.Analyzer, error) {
 	return newAnalyzer(cfg), nil
 }
 
-// validateConfig validates the configuration for the references linter.
+// validateConfig validates the configuration for the noreferences linter.
 func validateConfig(cfg *Config, fldPath *field.Path) field.ErrorList {
 	if cfg == nil {
 		return nil // nil config is valid, will use defaults

pkg/analysis/references/initializer_test.go renamed to pkg/analysis/noreferences/initializer_test.go

@@ -13,44 +13,44 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */
-package references_test
+package noreferences_test
 
 import (
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 
 	"k8s.io/apimachinery/pkg/util/validation/field"
 	"sigs.k8s.io/kube-api-linter/pkg/analysis/initializer"
-	"sigs.k8s.io/kube-api-linter/pkg/analysis/references"
+	"sigs.k8s.io/kube-api-linter/pkg/analysis/noreferences"
 )
 
-var _ = Describe("references initializer", func() {
+var _ = Describe("noreferences initializer", func() {
 	Context("config validation", func() {
 		type testCase struct {
-			config      *references.Config
+			config      *noreferences.Config
 			expectedErr string
 		}
 
 		DescribeTable("should validate the provided config", func(in testCase) {
-			ci, ok := references.Initializer().(initializer.ConfigurableAnalyzerInitializer)
+			ci, ok := noreferences.Initializer().(initializer.ConfigurableAnalyzerInitializer)
 			Expect(ok).To(BeTrue())
 
-			errs := ci.ValidateConfig(in.config, field.NewPath("references"))
+			errs := ci.ValidateConfig(in.config, field.NewPath("noreferences"))
 			if len(in.expectedErr) > 0 {
 				Expect(errs.ToAggregate()).To(MatchError(in.expectedErr))
 			} else {
 				Expect(errs).To(HaveLen(0), "No errors were expected")
 			}
 		},
-			Entry("With a valid references configuration with policy=NoReferences", testCase{
-				config: &references.Config{
-					Policy: references.PolicyNoReferences,
+			Entry("With a valid noreferences configuration with policy=NoReferences", testCase{
+				config: &noreferences.Config{
+					Policy: noreferences.PolicyNoReferences,
 				},
 				expectedErr: "",
 			}),
-			Entry("With a valid references configuration with policy=PreferAbbreviatedReference", testCase{
-				config: &references.Config{
-					Policy: references.PolicyPreferAbbreviatedReference,
+			Entry("With a valid noreferences configuration with policy=PreferAbbreviatedReference", testCase{
+				config: &noreferences.Config{
+					Policy: noreferences.PolicyPreferAbbreviatedReference,
 				},
 				expectedErr: "",
 			}),
@@ -59,14 +59,14 @@ var _ = Describe("references initializer", func() {
 				expectedErr: "",
 			}),
 			Entry("With an empty config", testCase{
-				config:      &references.Config{},
+				config:      &noreferences.Config{},
 				expectedErr: "",
 			}),
 			Entry("With an invalid policy value", testCase{
-				config: &references.Config{
+				config: &noreferences.Config{
 					Policy: "InvalidPolicy",
 				},
-				expectedErr: "references.policy: Unsupported value: \"InvalidPolicy\": supported values: \"PreferAbbreviatedReference\", \"NoReferences\"",
+				expectedErr: "noreferences.policy: Unsupported value: \"InvalidPolicy\": supported values: \"PreferAbbreviatedReference\", \"NoReferences\"",
 			}),
 		)
 	})