feat(AIP-190): UpperCamelCase service, method and message names. (#1623)

* feat(AIP-190): UpperCamelCase service, method and message names.

* allowlist some terms where the single letter word is not first

Author: jdcormie

docs/rules/0190/message-case.md

@@ -0,0 +1,39 @@
+---
+rule:
+  aip: 190
+  name: [core, '0190', message-case]
+  summary: Message names must use UpperCamelCase.
+permalink: /190/message-case
+redirect_from:
+  - /0190/message-case
+---
+
+# Message name case
+
+This rule enforces that all message names use UpperCamelCase, as mandated in
+[AIP-190][].
+
+## Details
+
+This rule checks all message names and complains if they are not UpperCamelCase,
+or if they contain consecutive uppercase letters not present in the allowlist.
+
+## Caveats
+
+This rule is an imperfect heuristic. The root problem is that AIP-190's definition of camel case starts with the prose form of the name as input, for example "XML HTTP Request". But this prose need not actually be written down anywhere – it may only exist inside the API author's head! This linter certainly doesn't have access to it. What we actually have is just the author’s _proposed_ capitalization. While some case violations are obvious on their face, like `snake_case` or `lowerCamelCase`, the rest require guessing. 
+
+Without knowing the actual boundaries of words, we can’t detect a violation like `XmlhttpRequest` where the letter H is incorrectly not capitalized. And even with access to a dictionary, we couldn’t tell whether a `CarpetService` should be actually capitalized as `CarPetService`! Finally, some terms can be written as a single word or multiple, like "nonempty" vs "non-empty". An API or even whole suite of APIs should probably be consistent about using one or the other but this rule isn't smart enough to know which of `CheckNotEmpty` or `CheckNonempty` is a violation. Fortunately, this undercapitalization type of error is less common and so we focus on the problem of excessive capitalization. 
+
+As a heuristic, we flag consecutive capital letters in the proposed name, for example the `XML` part of `XMLHttpRequest`. But there are legitimate words with just a single letter, like the “x” in x-ray or the “p” in p-value. We use an allowlist of exceptions to ignore them.
+
+## Disabling
+
+Users should not hesitate to disable this rule if it makes a mistake. To do so, include the “prose form” of your name, as defined by the Google Java Style Guide, in a comment above the proto element. For example:
+
+```proto
+// (-- api-linter: core::0190::message-case=disabled
+//     Prose message name: "Print T Shirt Request" --)
+message PrintTShirtRequest {}
+```
+
+[aip-190]: https://aip.dev/190

docs/rules/0190/method-case.md

@@ -0,0 +1,41 @@
+---
+rule:
+  aip: 190
+  name: [core, '0190', method-case]
+  summary: Method names must use UpperCamelCase.
+permalink: /190/method-case
+redirect_from:
+  - /0190/method-case
+---
+
+# Method name case
+
+This rule enforces that all method names use UpperCamelCase, as mandated in
+[AIP-190][].
+
+## Details
+
+This rule checks all method names and complains if they are not UpperCamelCase,
+or if they contain consecutive uppercase letters not present in the allowlist.
+
+## Caveats
+
+This rule is an imperfect heuristic. The root problem is that AIP-190's definition of camel case starts with the prose form of the name as input, for example "XML HTTP Request". But this prose need not actually be written down anywhere – it may only exist inside the API author's head! This linter certainly doesn't have access to it. What we actually have is just the author’s _proposed_ capitalization. While some case violations are obvious on their face, like `snake_case` or `lowerCamelCase`, the rest require guessing. 
+
+Without knowing the actual boundaries of words, we can’t detect a violation like `XmlhttpRequest` where the letter H is incorrectly not capitalized. And even with access to a dictionary, we couldn’t tell whether a `CarpetService` should be actually capitalized as `CarPetService`! Finally, some terms can be written as a single word or multiple, like "nonempty" vs "non-empty". An API or even whole suite of APIs should probably be consistent about using one or the other but this rule isn't smart enough to know which of `CheckNotEmpty` or `CheckNonempty` is a violation. Fortunately, this undercapitalization type of error is less common and so we focus on the problem of excessive capitalization. 
+
+As a heuristic, we flag consecutive capital letters in the proposed name, for example the `XML` part of `XMLHttpRequest`. But there are legitimate words with just a single letter, like the “x” in x-ray or the “p” in p-value. We use an allowlist of exceptions to ignore them.
+
+## Disabling
+
+Users should not hesitate to disable this rule if it makes a mistake. To do so, include the “prose form” of your name, as defined by the Google Java Style Guide, in a comment above the proto element. For example:
+
+```proto
+service TShirtService {
+  // (-- api-linter: core::0190::method-case=disabled
+  //     Prose method name: "Print T Shirt" --)
+  rpc PrintTShirt(PrintTShirtRequest) returns (PrintTShirtResponse) {}
+}
+```
+
+[aip-190]: https://aip.dev/190

docs/rules/0190/service-case.md

@@ -0,0 +1,39 @@
+---
+rule:
+  aip: 190
+  name: [core, '0190', service-case]
+  summary: Service names must use UpperCamelCase.
+permalink: /190/service-case
+redirect_from:
+  - /0190/service-case
+---
+
+# Service name case
+
+This rule enforces that all service names use UpperCamelCase, as mandated in
+[AIP-190][].
+
+## Details
+
+This rule checks all service names and complains if they are not UpperCamelCase,
+or if they contain consecutive uppercase letters not present in the allowlist.
+
+## Caveats
+
+This rule is an imperfect heuristic. The root problem is that AIP-190's definition of camel case starts with the prose form of the name as input, for example "XML HTTP Request". But this prose need not actually be written down anywhere – it may only exist inside the API author's head! This linter certainly doesn't have access to it. What we actually have is just the author’s _proposed_ capitalization. While some case violations are obvious on their face, like `snake_case` or `lowerCamelCase`, the rest require guessing. 
+
+Without knowing the actual boundaries of words, we can’t detect a violation like `XmlhttpRequest` where the letter H is incorrectly not capitalized. And even with access to a dictionary, we couldn’t tell whether a `CarpetService` should be actually capitalized as `CarPetService`! Finally, some terms can be written as a single word or multiple, like "nonempty" vs "non-empty". An API or even whole suite of APIs should probably be consistent about using one or the other but this rule isn't smart enough to know which of `CheckNotEmpty` or `CheckNonempty` is a violation. Fortunately, this undercapitalization type of error is less common and so we focus on the problem of excessive capitalization. 
+
+As a heuristic, we flag consecutive capital letters in the proposed name, for example the `XML` part of `XMLHttpRequest`. But there are legitimate words with just a single letter, like the “x” in x-ray or the “p” in p-value. We use an allowlist of exceptions to ignore them.
+
+## Disabling
+
+Users should not hesitate to disable this rule if it makes a mistake. To do so, include the “prose form” of your name, as defined by the Google Java Style Guide, in a comment above the proto element. For example:
+
+```proto
+// (-- api-linter: core::0190::service-case=disabled
+//     Prose service name: "T Shirt Service" --)
+service TShirtService { ... }
+```
+
+[aip-190]: https://aip.dev/190

rules/aip0190/aip0190.go

@@ -0,0 +1,60 @@
+// Copyright 2024 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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 aip0190
+
+import (
+	"regexp"
+	"strings"
+
+	"github.com/googleapis/api-linter/v2/lint"
+)
+
+// AddRules accepts a register function and registers each of
+// this AIP's rules to it.
+func AddRules(r lint.RuleRegistry) error {
+	return r.Register(
+		190,
+		messageCase,
+		methodCase,
+		serviceCase,
+	)
+}
+
+var termsWithSingleLetterWords = []string{
+	"AStar", "BTree", "RTree", "MTree", "QTree",
+	"NGram", "NAry", "NWay", "KWay", "QLearning",
+	"XAxis", "YAxis", "ZAxis", "KMeans", "PlanA",
+	"PlanB", "PValue", "TTest", "TValue",
+	"TypeIError", "TypeIIError", "ZScore",
+	"FTest", "FScore", "HIndex", "INode", "VNode",
+	"LValue", "RValue", "PCode", "SExpression", "ETag",
+	"IFrame", "VCard", "CName", "QName", "OAuth",
+	"ABTest", "DPad", "ZIndex", "ZOrder", "ZBuffer",
+	"XRay",
+}
+
+// validNameRegex validates that a string is a valid UpperCamelCase name
+// without illegal consecutive capital letters, unless they match allowlisted terms.
+var validNameRegex = regexp.MustCompile(`^(?:` +
+	// A capitalized word from the prose form of the name.
+	`[A-Z][a-z0-9]+|` +
+	// Or an allowlisted term containing single letter "words".
+	`(?:` + strings.Join(termsWithSingleLetterWords, "|") + `)[a-z0-9]*` +
+	`)+$`)
+
+// isValidCamelCase checks if the given name follows AIP-190 case requirements.
+func isValidCamelCase(name string) bool {
+	return validNameRegex.MatchString(name)
+}

rules/aip0190/aip0190_test.go

@@ -0,0 +1,60 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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 aip0190
+
+import "testing"
+
+func TestIsValidCamelCase(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  bool
+	}{
+		{"ValidNormal", "CustomerId", true},
+		{"ValidXmlHttpRequest", "XmlHttpRequest", true},
+		{"ValidIpv6OnIosOptions", "Ipv6OnIosOptions", true},
+		{"ValidABTestingService", "ABTestingService", true},
+		{"ValidHttpABTestingService", "HttpABTestingService", true},
+		// Multiple allowlist entries with trailing lowercase letters.
+		{"ValidABTestETaggingRequest", "ABTestETaggingRequest", true},
+		// Single letter words can also appear at the end of an allowlisted term.
+		{"ValidPlanB", "ExecutePlanB", true},
+		// We sometimes require leading and trailing context for single letters .
+		{"ValidTypeIIError", "TypeIIErrorResponse", true},
+		{"ValidXRay", "XRay", true},
+		{"ValidOAuth", "OAuth", true},
+		{"ValidABTest", "ABTest", true},
+		{"InvalidTShirtService", "TShirtService", false},
+		{"InvalidSnakeCase", "snake_case", false},
+		{"InvalidLowerCamelCase", "lowerCamelCase", false},
+		{"InvalidLowercase", "lowercase", false},
+		{"InvalidCustomerID", "CustomerID", false},
+		{"InvalidXMLHTTPRequest", "XMLHTTPRequest", false},
+		{"InvalidIPv6OnIOSOptions", "IPv6OnIOSOptions", false},
+		{"InvalidHTTPABTestingService", "HTTPABTestingService", false},
+		{"InvalidEMail", "EMail", false},
+		{"InvalidEBook", "EBook", false},
+		{"InvalidECommerce", "ECommerce", false},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			got := isValidCamelCase(test.input)
+			if got != test.want {
+				t.Errorf("isValidCamelCase(%q) = %t; want %t", test.input, got, test.want)
+			}
+		})
+	}
+}

rules/aip0190/message_case.go

@@ -0,0 +1,36 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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 aip0190
+
+import (
+	"fmt"
+
+	"github.com/googleapis/api-linter/v2/lint"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+var messageCase = &lint.MessageRule{
+	Name: lint.NewRuleName(190, "message-case"),
+	LintMessage: func(m protoreflect.MessageDescriptor) []lint.Problem {
+		name := string(m.Name())
+		if !isValidCamelCase(name) {
+			return []lint.Problem{{
+				Message:    fmt.Sprintf("Message name %q must use UpperCamelCase.", name),
+				Descriptor: m,
+			}}
+		}
+		return nil
+	},
+}

rules/aip0190/message_case_test.go

@@ -0,0 +1,44 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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 aip0190
+
+import (
+	"testing"
+
+	"github.com/googleapis/api-linter/v2/rules/internal/testutils"
+)
+
+func TestMessageCase(t *testing.T) {
+	for _, test := range []struct {
+		name        string
+		MessageName string
+		problems    testutils.Problems
+	}{
+		{"Valid", "Book", testutils.Problems{}},
+		{"InvalidCustomerID", "CustomerID", testutils.Problems{{Message: `Message name "CustomerID" must use UpperCamelCase.`}}},
+	} {
+		t.Run(test.name, func(t *testing.T) {
+			f := testutils.ParseProto3Tmpl(t, `
+			message {{ .MessageName }} {
+				string name = 1;
+			}
+		`, test)
+			m := f.Messages().Get(0)
+			if diff := test.problems.SetDescriptor(m).Diff(messageCase.Lint(f)); diff != "" {
+				t.Error(diff)
+			}
+		})
+	}
+}

rules/aip0190/method_case.go

@@ -0,0 +1,36 @@
+// Copyright 2026 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// 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 aip0190
+
+import (
+	"fmt"
+
+	"github.com/googleapis/api-linter/v2/lint"
+	"google.golang.org/protobuf/reflect/protoreflect"
+)
+
+var methodCase = &lint.MethodRule{
+	Name: lint.NewRuleName(190, "method-case"),
+	LintMethod: func(m protoreflect.MethodDescriptor) []lint.Problem {
+		name := string(m.Name())
+		if !isValidCamelCase(name) {
+			return []lint.Problem{{
+				Message:    fmt.Sprintf("Method name %q must use UpperCamelCase.", name),
+				Descriptor: m,
+			}}
+		}
+		return nil
+	},
+}