Merge pull request #17 from arran4/perf-optimize-cmalltitle-10160609927452003911

⚡ Optimize CMAllTitle string allocations

Author: arran4

types.go

@@ -36,7 +36,7 @@ type SeparatorWord string
 
 // String implementations
 func (w SingleCaseWord) String() string     { return strings.ToLower(string(w)) }
-func (w FirstUpperCaseWord) String() string { return UpperCaseFirst(strings.ToLower(string(w))) }
+func (w FirstUpperCaseWord) String() string { return upperCaseFirstLower(string(w)) }
 func (w AcronymWord) String() string        { return string(w) }
 func (w UpperCaseWord) String() string      { return strings.ToUpper(string(w)) }
 func (w SeparatorWord) String() string      { return string(w) }
@@ -118,6 +118,46 @@ func MustLowerCaseFirst(s string) string {
 	return res
 }
 
+// upperCaseFirstLower capitalizes the first character and lowercases the rest.
+func upperCaseFirstLower(s string) string {
+	if s == "" {
+		return ""
+	}
+	r, size := utf8.DecodeRuneInString(s)
+	if r == utf8.RuneError && size == 1 {
+		// Invalid UTF-8 start byte.
+		// We want to replace it with RuneError (like strings.ToLower/ToUpper do).
+		// So we force needChange.
+	} else if r == utf8.RuneError {
+		// Valid RuneError (U+FFFD)
+	}
+
+	u := unicode.ToUpper(r)
+
+	// Check if changes are needed
+	needChange := (r != u) || (r == utf8.RuneError && size == 1)
+	if !needChange {
+		for _, rc := range s[size:] {
+			if unicode.ToLower(rc) != rc {
+				needChange = true
+				break
+			}
+		}
+	}
+
+	if !needChange {
+		return s
+	}
+
+	var b strings.Builder
+	b.Grow(len(s))
+	b.WriteRune(u)
+	for _, rc := range s[size:] {
+		b.WriteRune(unicode.ToLower(rc))
+	}
+	return b.String()
+}
+
 func (w ExactCaseWord) String() string { return string(w) }
 
 // Options
@@ -231,7 +271,7 @@ func WordsToFormattedCase(words []Word, opts ...any) (string, error) {
 			} else if cfg.allLower || cfg.whispering {
 				w = strings.ToLower(w)
 			} else if cfg.caseMode == CMAllTitle {
-				w = UpperCaseFirst(strings.ToLower(w))
+				w = upperCaseFirstLower(w)
 			} else {
 				w = strings.ToLower(w)
 			}
@@ -262,7 +302,7 @@ func WordsToFormattedCase(words []Word, opts ...any) (string, error) {
 			} else if cfg.whispering {
 				w = strings.ToLower(w)
 			} else if cfg.caseMode == CMAllTitle {
-				w = UpperCaseFirst(strings.ToLower(w))
+				w = upperCaseFirstLower(w)
 			}
 		case UpperCaseWord:
 			w = word.String()
@@ -271,7 +311,7 @@ func WordsToFormattedCase(words []Word, opts ...any) (string, error) {
 			} else if cfg.allLower || cfg.whispering {
 				w = strings.ToLower(w)
 			} else if cfg.caseMode == CMAllTitle {
-				w = UpperCaseFirst(strings.ToLower(w))
+				w = upperCaseFirstLower(w)
 			} else {
 				w = strings.ToLower(w)
 			}

types_internal_test.go

@@ -0,0 +1,101 @@
+package strings2
+
+import (
+	"testing"
+)
+
+func TestUpperCaseFirstLower_Correctness(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		expected string
+	}{
+		{
+			name:     "Empty String",
+			input:    "",
+			expected: "",
+		},
+		{
+			name:     "ASCII Lower",
+			input:    "test",
+			expected: "Test",
+		},
+		{
+			name:     "ASCII Mixed",
+			input:    "tEsT",
+			expected: "Test",
+		},
+		{
+			name:     "ASCII Upper",
+			input:    "TEST",
+			expected: "Test",
+		},
+		{
+			name:     "Already Correct",
+			input:    "Test",
+			expected: "Test",
+		},
+		{
+			name:     "Unicode Lower",
+			input:    "äpfel",
+			expected: "Äpfel",
+		},
+		{
+			name:     "Unicode Upper",
+			input:    "ÄPFEL",
+			expected: "Äpfel",
+		},
+		{
+			name:     "Unicode Mixed",
+			input:    "äPfEl",
+			expected: "Äpfel",
+		},
+		{
+			name:     "Special Char Start",
+			input:    "!test",
+			expected: "!test",
+		},
+		{
+			name:     "Number Start",
+			input:    "1test",
+			expected: "1test",
+		},
+		{
+			name:     "Invalid UTF-8",
+			input:    "\xff\xfe\xfd",
+			expected: "\uFFFD\uFFFD\uFFFD",
+		},
+		{
+			name:     "Partial Invalid UTF-8",
+			input:    "test\xff",
+			expected: "Test\uFFFD",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := upperCaseFirstLower(tt.input)
+			if got != tt.expected {
+				t.Errorf("upperCaseFirstLower(%q) = %q, want %q", tt.input, got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestUpperCaseFirstLower_Allocations(t *testing.T) {
+	// Tests that no allocation occurs if the string is already correct
+	input := "Test"
+	if testing.AllocsPerRun(10, func() {
+		upperCaseFirstLower(input)
+	}) > 0 {
+		t.Errorf("upperCaseFirstLower(%q) allocated memory when no change was needed", input)
+	}
+
+	// Test that allocation occurs when change IS needed
+	input2 := "test"
+	if testing.AllocsPerRun(10, func() {
+		upperCaseFirstLower(input2)
+	}) == 0 {
+		t.Errorf("upperCaseFirstLower(%q) did not allocate memory when change was needed", input2)
+	}
+}