feat: add GoPascalCase and GoCamelCase for Go-conventional acronym casing

PascalCase("execute_sql_query") returns "ExecuteSqlQuery", but Go
convention (enforced by revive/golint) expects "ExecuteSQLQuery".

GoPascalCase and GoCamelCase post-process the result to uppercase
registered acronyms (SQL, API, URL, ID, HTTP, JSON, etc.) from the
engine's acronym registry.

Available as both package-level functions and Engine methods.

Author: cv

inflect_gen.go

@@ -81,6 +81,70 @@ func TitleCase(s string) string {
 	return PascalCase(s)
 }
 
+// GoPascalCase converts a string to PascalCase with Go-conventional acronym
+// casing. Registered acronyms (SQL, API, URL, ID, etc.) are fully uppercased
+// per Go naming conventions enforced by linters like revive and golint.
+//
+// This differs from [PascalCase] which treats acronyms as regular words:
+// PascalCase("execute_sql_query") returns "ExecuteSqlQuery", while
+// GoPascalCase("execute_sql_query") returns "ExecuteSQLQuery".
+//
+// Acronyms are sourced from the engine's acronym registry (see [AddAcronym],
+// [GetAcronyms]). The default set includes common acronyms like API, SQL, URL,
+// HTTP, ID, JSON, XML, etc.
+//
+// Examples:
+//   - GoPascalCase("execute_sql_query") returns "ExecuteSQLQuery"
+//   - GoPascalCase("get_api_key") returns "GetAPIKey"
+//   - GoPascalCase("list_urls") returns "ListURLs"
+//   - GoPascalCase("hello_world") returns "HelloWorld"
+//   - GoPascalCase("user_id") returns "UserID"
+func GoPascalCase(s string) string {
+	return defaultEngine.GoPascalCase(s)
+}
+
+// GoPascalCase converts a string to PascalCase with Go-conventional acronym
+// casing. See the package-level [GoPascalCase] for details and examples.
+func (e *Engine) GoPascalCase(s string) string {
+	return applyAcronymCasing(toCamelOrPascal(s, true), e)
+}
+
+// GoCamelCase converts a string to camelCase with Go-conventional acronym
+// casing. Registered acronyms in non-leading positions are fully uppercased.
+//
+// This differs from [CamelCase] which treats acronyms as regular words:
+// CamelCase("get_sql_query") returns "getSqlQuery", while
+// GoCamelCase("get_sql_query") returns "getSQLQuery".
+//
+// When an acronym appears at the start, it remains lowercase per camelCase rules:
+// GoCamelCase("sql_query") returns "sqlQuery" (not "sQLQuery").
+//
+// Examples:
+//   - GoCamelCase("get_sql_query") returns "getSQLQuery"
+//   - GoCamelCase("get_api_key") returns "getAPIKey"
+//   - GoCamelCase("sql_query") returns "sqlQuery"
+//   - GoCamelCase("hello_world") returns "helloWorld"
+func GoCamelCase(s string) string {
+	return defaultEngine.GoCamelCase(s)
+}
+
+// GoCamelCase converts a string to camelCase with Go-conventional acronym
+// casing. See the package-level [GoCamelCase] for details and examples.
+func (e *Engine) GoCamelCase(s string) string {
+	return applyAcronymCasing(toCamelOrPascal(s, false), e)
+}
+
+// applyAcronymCasing post-processes a PascalCase or camelCase string to
+// uppercase registered acronyms. For example, "ExecuteSqlQuery" becomes
+// "ExecuteSQLQuery" when "SQL" is a registered acronym.
+func applyAcronymCasing(s string, e *Engine) string {
+	for _, acr := range e.GetAcronyms() {
+		titled := strings.ToUpper(acr[:1]) + strings.ToLower(acr[1:])
+		s = strings.ReplaceAll(s, titled, acr)
+	}
+	return s
+}
+
 // CamelCase converts a string to camelCase.
 //
 // It handles snake_case, kebab-case, and mixed inputs.

internal/inflect/case.go

@@ -199,6 +199,71 @@ func TestPascalCase(t *testing.T) {
 	}
 }
 
+func TestGoPascalCase(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		// Acronym casing (the key difference from PascalCase)
+		{name: "SQL acronym", input: "execute_sql_query", want: "ExecuteSQLQuery"},
+		{name: "API acronym", input: "get_api_key", want: "GetAPIKey"},
+		{name: "URL acronym", input: "list_urls", want: "ListURLs"},
+		{name: "ID acronym", input: "user_id", want: "UserID"},
+		{name: "HTTP acronym", input: "http_server", want: "HTTPServer"},
+		{name: "JSON acronym", input: "parse_json_data", want: "ParseJSONData"},
+		{name: "multiple acronyms", input: "get_api_url", want: "GetAPIURL"},
+		{name: "UUID acronym", input: "generate_uuid", want: "GenerateUUID"},
+
+		// Non-acronym words unchanged
+		{name: "no acronyms", input: "hello_world", want: "HelloWorld"},
+		{name: "three words", input: "one_two_three", want: "OneTwoThree"},
+
+		// Edge cases
+		{name: "empty string", input: "", want: ""},
+		{name: "single word", input: "hello", want: "Hello"},
+		{name: "kebab-case", input: "get-api-key", want: "GetAPIKey"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := inflect.GoPascalCase(tt.input)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestGoCamelCase(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+		want  string
+	}{
+		// Acronym casing in non-leading position
+		{name: "SQL acronym", input: "get_sql_query", want: "getSQLQuery"},
+		{name: "API acronym", input: "get_api_key", want: "getAPIKey"},
+		{name: "URL acronym", input: "get_url", want: "getURL"},
+		{name: "ID acronym", input: "get_user_id", want: "getUserID"},
+
+		// Leading acronym stays lowercase (camelCase rule)
+		{name: "leading acronym", input: "sql_query", want: "sqlQuery"},
+		{name: "leading http", input: "http_server", want: "httpServer"},
+
+		// Non-acronym words unchanged
+		{name: "no acronyms", input: "hello_world", want: "helloWorld"},
+
+		// Edge cases
+		{name: "empty string", input: "", want: ""},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := inflect.GoCamelCase(tt.input)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
 func TestTitleCase(t *testing.T) {
 	// TitleCase should be an alias for PascalCase
 	tests := []struct {