fix(rules): evaluate method synonyms on word boundaries (#1643)

* fix(rules): evaluate method synonyms on word boundaries

The synonyms rules in AIP-131, AIP-133, and AIP-134 were incorrectly
flagging method names like "ReadyPackage", "ReadingRoom", "PosterBoy",
or "MakerSpace" because they only checked if the name started with
the synonym prefix ("Read", "Post", "Make").

This change introduces a shared helper utils.HasWordBoundaryPrefix
in rules/internal/utils/casing.go and uses it across AIP-131, AIP-133,
and AIP-134, detecting word boundaries by checking if the character
immediately following the prefix is uppercase (indicating a new word
in UpperCamelCase) or if the identifier equals the prefix.

Fixes b/555805873

* Apply suggestion from @gemini-code-assist[bot]

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: quirogas

rules/aip0131/synonyms.go

@@ -20,6 +20,7 @@ import (
 
 	"github.com/googleapis/api-linter/v2/lint"
 	"github.com/googleapis/api-linter/v2/locations"
+	"github.com/googleapis/api-linter/v2/rules/internal/utils"
 	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
@@ -29,7 +30,7 @@ var synonyms = &lint.MethodRule{
 	LintMethod: func(m protoreflect.MethodDescriptor) []lint.Problem {
 		name := string(m.Name())
 		for _, syn := range []string{"Acquire", "Fetch", "Lookup", "Read", "Retrieve"} {
-			if strings.HasPrefix(name, syn) {
+			if utils.HasWordBoundaryPrefix(name, syn) {
 				return []lint.Problem{{
 					Message: fmt.Sprintf(
 						`%q can be a synonym for "Get". Should this be a Get method?`,

rules/aip0131/synonyms_test.go

@@ -31,6 +31,12 @@ func TestSynonyms(t *testing.T) {
 		{"LookupBook", testutils.Problems{{Suggestion: "GetBook"}}},
 		{"ReadBook", testutils.Problems{{Suggestion: "GetBook"}}},
 		{"RetrieveBook", testutils.Problems{{Suggestion: "GetBook"}}},
+		{"ReadyPackage", testutils.Problems{}},
+		{"ReadingRoom", testutils.Problems{}},
+		{"LookupsReport", testutils.Problems{}},
+		{"AcquirerAccount", testutils.Problems{}},
+		{"FetchingDog", testutils.Problems{}},
+		{"RetrieverConfig", testutils.Problems{}},
 	}
 	for _, test := range tests {
 		file := testutils.ParseProto3Tmpl(t, `

rules/aip0133/synonyms.go

@@ -20,6 +20,7 @@ import (
 
 	"github.com/googleapis/api-linter/v2/lint"
 	"github.com/googleapis/api-linter/v2/locations"
+	"github.com/googleapis/api-linter/v2/rules/internal/utils"
 	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
@@ -29,7 +30,7 @@ var synonyms = &lint.MethodRule{
 	LintMethod: func(m protoreflect.MethodDescriptor) []lint.Problem {
 		name := string(m.Name())
 		for _, syn := range []string{"Insert", "Make", "Post"} {
-			if strings.HasPrefix(name, syn) {
+			if utils.HasWordBoundaryPrefix(name, syn) {
 				return []lint.Problem{{
 					Message: fmt.Sprintf(
 						`%q can be a synonym for "Create". Should this be a Create method?`,

rules/aip0133/synonyms_test.go

@@ -29,6 +29,9 @@ func TestSynonyms(t *testing.T) {
 		{"InsertBook", testutils.Problems{{Suggestion: "CreateBook"}}},
 		{"MakeBook", testutils.Problems{{Suggestion: "CreateBook"}}},
 		{"PostBook", testutils.Problems{{Suggestion: "CreateBook"}}},
+		{"PosterBoy", testutils.Problems{}},
+		{"MakerSpace", testutils.Problems{}},
+		{"InsertionSort", testutils.Problems{}},
 	}
 	for _, test := range tests {
 		t.Run(test.MethodName, func(t *testing.T) {

rules/aip0134/synonyms.go

@@ -17,10 +17,10 @@ package aip0134
 import (
 	"fmt"
 	"strings"
-	"unicode"
 
 	"github.com/googleapis/api-linter/v2/lint"
 	"github.com/googleapis/api-linter/v2/locations"
+	"github.com/googleapis/api-linter/v2/rules/internal/utils"
 	"google.golang.org/protobuf/reflect/protoreflect"
 )
 
@@ -33,21 +33,16 @@ var synonyms = &lint.MethodRule{
 	LintMethod: func(m protoreflect.MethodDescriptor) []lint.Problem {
 		name := string(m.Name())
 		for _, syn := range []string{"Patch", "Put", "Set"} {
-			if strings.HasPrefix(name, syn) {
-				synLen := len(syn)
-				nameLen := len(name)
-				// Check for word boundary: either exact match or next char is uppercase
-				if nameLen == synLen || unicode.IsUpper(rune(name[synLen])) {
-					return []lint.Problem{{
-						Message: fmt.Sprintf(
-							`%q can be a synonym for "Update". Should this be a Update method?`,
-							syn,
-						),
-						Descriptor: m,
-						Location:   locations.DescriptorName(m),
-						Suggestion: strings.Replace(name, syn, "Update", 1),
-					}}
-				}
+			if utils.HasWordBoundaryPrefix(name, syn) {
+				return []lint.Problem{{
+					Message: fmt.Sprintf(
+						`%q can be a synonym for "Update". Should this be an Update method?`,
+						syn,
+					),
+					Descriptor: m,
+					Location:   locations.DescriptorName(m),
+					Suggestion: strings.Replace(name, syn, "Update", 1),
+				}}
 			}
 		}
 		return nil

rules/internal/utils/casing.go

@@ -14,6 +14,29 @@
 
 package utils
 
+import (
+	"strings"
+	"unicode"
+	"unicode/utf8"
+)
+
+// HasWordBoundaryPrefix reports whether the UpperCamelCase identifier s begins with
+// prefix on a word boundary (i.e. s equals prefix or the character immediately
+// following prefix is uppercase).
+//
+// Both s and prefix are case-sensitive. If prefix is empty or s does not start with
+// prefix, it returns false.
+func HasWordBoundaryPrefix(s, prefix string) bool {
+	if prefix == "" || !strings.HasPrefix(s, prefix) {
+		return false
+	}
+	if len(s) == len(prefix) {
+		return true
+	}
+	r, _ := utf8.DecodeRuneInString(s[len(prefix):])
+	return unicode.IsUpper(r)
+}
+
 // ToUpperCamelCase returns the UpperCamelCase of a string, including removing
 // delimiters (_,-,., ) and using them to denote a new word.
 func ToUpperCamelCase(s string) string {

rules/internal/utils/casing_test.go

@@ -132,7 +132,102 @@ func TestToUpperCamelCase(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			got := ToUpperCamelCase(test.input)
 			if got != test.want {
-				t.Errorf("ToLowerCamelCase(%q) = %q, got %q", test.input, test.want, got)
+				t.Errorf("ToUpperCamelCase(%q) = %q, got %q", test.input, test.want, got)
+			}
+		})
+	}
+}
+
+func TestHasWordBoundaryPrefix(t *testing.T) {
+	for _, test := range []struct {
+		name   string
+		s      string
+		prefix string
+		want   bool
+	}{
+		{
+			name:   "ExactMatch",
+			s:      "Read",
+			prefix: "Read",
+			want:   true,
+		},
+		{
+			name:   "WordBoundaryUppercase",
+			s:      "ReadBook",
+			prefix: "Read",
+			want:   true,
+		},
+		{
+			name:   "WordBoundaryAcronym",
+			s:      "ReadHTTPStream",
+			prefix: "Read",
+			want:   true,
+		},
+		{
+			name:   "NonBoundaryLowercaseSuffix",
+			s:      "ReadyPackage",
+			prefix: "Read",
+			want:   false,
+		},
+		{
+			name:   "NonBoundaryIngSuffix",
+			s:      "ReadingRoom",
+			prefix: "Read",
+			want:   false,
+		},
+		{
+			name:   "DifferentPrefix",
+			s:      "GetBook",
+			prefix: "Read",
+			want:   false,
+		},
+		{
+			name:   "ShorterThanPrefix",
+			s:      "Re",
+			prefix: "Read",
+			want:   false,
+		},
+		{
+			name:   "EmptyString",
+			s:      "",
+			prefix: "Read",
+			want:   false,
+		},
+		{
+			name:   "EmptyPrefix",
+			s:      "Read",
+			prefix: "",
+			want:   false,
+		},
+		{
+			name:   "BothEmpty",
+			s:      "",
+			prefix: "",
+			want:   false,
+		},
+		{
+			name:   "DigitSuffix",
+			s:      "Read2Book",
+			prefix: "Read",
+			want:   false,
+		},
+		{
+			name:   "MultibyteUpper",
+			s:      "ReadÜber",
+			prefix: "Read",
+			want:   true,
+		},
+		{
+			name:   "MultibyteLower",
+			s:      "Readüber",
+			prefix: "Read",
+			want:   false,
+		},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			got := HasWordBoundaryPrefix(test.s, test.prefix)
+			if got != test.want {
+				t.Errorf("HasWordBoundaryPrefix(%q, %q) = %v, want %v", test.s, test.prefix, got, test.want)
 			}
 		})
 	}