[java-i18n] IDEA-383845 Fix StringUtil.wordsToBeginFromUpperCase with prepositions in Title capitalization

GitOrigin-RevId: 4efb81ba5bdb8143b35892c5262a75bc33f6d1c7

Author: jreznot

jvm/jvm-analysis-api/src/com/intellij/codeInspection/NlsCapitalizationUtil.java

@@ -5,86 +5,19 @@
 import org.jetbrains.annotations.Nls;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.*;
-import java.util.regex.Pattern;
+import java.util.List;
 
 public final class NlsCapitalizationUtil {
-  private static final Set<String> TITLE_CASE_LOWERCASE_WORDS = Set.of(
-    "a", "an", "the",
-    "and", "or", "but",
-    "at", "by", "for", "from", "in", "into", "of", "off", "on", "onto", "out", "over", "to", "up", "with"
-  );
-  private static final Pattern PERIOD_PATTERN = Pattern.compile("\\.(?!\\s*$)");
-  private static final Pattern DOUBLE_QUOTES_PATTERN = Pattern.compile("[“”\"]");
-  private static final Pattern EXCLAMATION_PATTERN = Pattern.compile("!");
-  private static final Pattern CONTRACTION_PATTERN = Pattern.compile("(?i)\\b(can't|won't|isn't|aren't|wasn't|weren't|hasn't|haven't|hadn't|doesn't|don't|didn't|shouldn't|wouldn't|couldn't|mightn't|mustn't)\\b(?<!Don't)");
-  private static final Pattern WHITESPACE_SPLIT_PATTERN = Pattern.compile("(?<=\\s)|(?=\\s)");
-  private static final Pattern PUNCTUATION_WITH_WORD_PATTERN = Pattern.compile("(^\\P{Alnum}*)([\\p{Alnum}]+)(\\P{Alnum}*$)");
-  private static final Pattern LEADING_PUNCTUATION_WITH_FIRST_LETTER_PATTERN = Pattern.compile("(^\\P{Alnum}*)(\\p{Alpha})(.*)");
-  private static final Pattern SPECIAL_PREFIX_PATTERN = Pattern.compile("^[.*~].*");
-
   public static boolean isCapitalizationSatisfied(String value, Nls.Capitalization capitalization) {
     if (StringUtil.isEmpty(value) || capitalization == Nls.Capitalization.NotSpecified) {
       return true;
     }
+
     return capitalization == Nls.Capitalization.Title
-           ? checkTitleCapitalization(value)
+           ? StringUtil.wordsToBeginFromUpperCase(value).equals(value)
            : checkSentenceCapitalization(value);
   }
 
-  private static List<String> splitByWhitespace(String s) {
-    return Arrays.stream(s.trim().split("\\s+"))
-      .filter(str -> !str.isEmpty())
-      .toList();
-  }
-
-  private static boolean checkTitleCapitalization(@NotNull String value) {
-    List<String> words = splitByWhitespace(value);
-    final int wordCount = words.size();
-    if (wordCount == 0) return true;
-    for (int i = 0; i < wordCount; i++) {
-      String word = words.get(i);
-      if (word.isEmpty()) continue;
-      String cleanWord = stripPunctuation(word);
-      if (cleanWord.isEmpty()) continue;
-      // Check if it's a special case (like iOS, macOS)
-      if (hasInternalCapitalization(cleanWord)) {
-        continue;
-      }
-      if (i == 0 || i == wordCount - 1) {
-        if (!isCapitalizedWord(cleanWord)) return false;
-      }
-      else {
-        String lowerWord = cleanWord.toLowerCase(Locale.ENGLISH);
-        if (TITLE_CASE_LOWERCASE_WORDS.contains(lowerWord)) {
-          if (isCapitalizedWord(cleanWord)) return false;
-        }
-        else {
-          if (!isCapitalizedWord(cleanWord)) return false;
-        }
-      }
-    }
-    return true;
-  }
-
-  private static boolean hasInternalCapitalization(@NotNull String word) {
-    if (word.length() <= 1) return false;
-    boolean hasLowerCase = false;
-    boolean hasUpperCaseAfterFirst = false;
-    for (int i = 0; i < word.length(); i++) {
-      char c = word.charAt(i);
-      if (Character.isLetter(c)) {
-        if (Character.isLowerCase(c)) {
-          hasLowerCase = true;
-        }
-        else if (i > 0 && Character.isUpperCase(c)) {
-          hasUpperCaseAfterFirst = true;
-        }
-      }
-    }
-    return hasLowerCase && hasUpperCaseAfterFirst;
-  }
-
   private static boolean checkSentenceCapitalization(@NotNull String value) {
     List<String> words = StringUtil.split(value, " ");
     final int wordCount = words.size();
@@ -116,98 +49,9 @@ private static boolean isCapitalizedWord(String word) {
     return !word.isEmpty() && Character.isLetter(word.charAt(0)) && Character.isUpperCase(word.charAt(0));
   }
 
-  private static @NotNull String stripPunctuation(@NotNull String word) {
-    int start = 0;
-    int end = word.length();
-    while (start < end && !Character.isLetterOrDigit(word.charAt(start))) {
-      start++;
-    }
-    while (end > start && !Character.isLetterOrDigit(word.charAt(end - 1))) {
-      end--;
-    }
-    return start < end ? word.substring(start, end) : "";
-  }
-
-  public static boolean checkPunctuation(@NotNull String value) {
-    if (PERIOD_PATTERN.matcher(value).find()) {
-      return value.endsWith(".");
-    }
-    if (value.endsWith(".")) {
-      return false;
-    }
-    if (DOUBLE_QUOTES_PATTERN.matcher(value).find()) {
-      return false;
-    }
-    if (EXCLAMATION_PATTERN.matcher(value).find()) {
-      return false;
-    }
-    if (CONTRACTION_PATTERN.matcher(value).find()) {
-      return false;
-    }
-    return true;
-  }
-
   public static @NotNull String fixValue(String string, Nls.Capitalization capitalization) {
-    if (capitalization == Nls.Capitalization.Title) {
-      return fixTitleCapitalization(string);
-    }
-    else {
-      return StringUtil.capitalize(StringUtil.wordsToBeginFromLowerCase(string));
-    }
-  }
-
-  private static String fixTitleCapitalization(String text) {
-    if (text == null || text.isBlank()) return text;
-    String[] tokens = WHITESPACE_SPLIT_PATTERN.split(text);
-
-    int firstWordIndex = -1, lastWordIndex = -1;
-    for (int i = 0; i < tokens.length; i++) {
-      String cleanedToken = stripPunctuation(tokens[i]);
-      if (!cleanedToken.isEmpty()) {
-        if (firstWordIndex == -1) firstWordIndex = i;
-        lastWordIndex = i;
-      }
-    }
-    if (firstWordIndex == -1) return text;
-
-    StringBuilder result = new StringBuilder();
-    for (int i = 0; i < tokens.length; i++) {
-      String token = tokens[i];
-      if (token.isBlank()) {
-        result.append(token);
-        continue;
-      }
-      String cleanedToken = stripPunctuation(token);
-      if (cleanedToken.isEmpty()) {
-        result.append(token);
-        continue;
-      }
-      String lowercaseToken = cleanedToken.toLowerCase(Locale.ENGLISH);
-      boolean isFirstWord = i == firstWordIndex;
-      boolean isLastWord = i == lastWordIndex;
-
-      if (!isFirstWord && !isLastWord && TITLE_CASE_LOWERCASE_WORDS.contains(lowercaseToken)) {
-        result.append(applyLowercaseToTokenPreservingPunctuation(token, lowercaseToken));
-      } else if (hasInternalCapitalization(cleanedToken)) {
-        result.append(token);
-      } else {
-        result.append(capitalizeFirstLetter(token));
-      }
-    }
-    return result.toString();
-  }
-
-  private static String applyLowercaseToTokenPreservingPunctuation(String token, String lowercaseWord) {
-    var matcher = PUNCTUATION_WITH_WORD_PATTERN.matcher(token);
-    return matcher.matches() ? matcher.group(1) + lowercaseWord + matcher.group(3) : token;
-  }
-
-  private static String capitalizeFirstLetter(String token) {
-    if (token.isEmpty() || SPECIAL_PREFIX_PATTERN.matcher(token).matches()) return token;
-    var matcher = LEADING_PUNCTUATION_WITH_FIRST_LETTER_PATTERN.matcher(token);
-    if (matcher.matches()) {
-      return matcher.group(1) + Character.toUpperCase(matcher.group(2).charAt(0)) + matcher.group(3);
-    }
-    return token;
+    return capitalization == Nls.Capitalization.Title
+           ? StringUtil.wordsToBeginFromUpperCase(string)
+           : StringUtil.capitalize(StringUtil.wordsToBeginFromLowerCase(string));
   }
 }

jvm/jvm-analysis-java-tests/testSrc/com/intellij/codeInspection/NlsCapitalizationUtilTest.java

@@ -18,7 +18,6 @@
 import junit.framework.TestCase;
 import org.jetbrains.annotations.Nls;
 
-import static com.intellij.codeInspection.NlsCapitalizationUtil.checkPunctuation;
 import static com.intellij.codeInspection.NlsCapitalizationUtil.isCapitalizationSatisfied;
 
 public class NlsCapitalizationUtilTest extends TestCase {
@@ -118,6 +117,8 @@ public void testTitleCapitalizationPrepositions() {
     assertTitle("Search in Files");
     assertTitle("Go to Declaration");
     assertTitle("Copy from Here");
+    assertTitle("Paste as Plain Text");
+    assertTitle("Open In…");
   }
 
   public void testTitleCapitalizationFirstAndLastWords() {
@@ -130,43 +131,11 @@ public void testTitleCapitalizationNotSatisfied() {
     assertNotCapitalization("Compare With The Latest Repository Version", Nls.Capitalization.Title);
     assertNotCapitalization("Search And Replace", Nls.Capitalization.Title);
     assertNotCapitalization("compare with Latest Version", Nls.Capitalization.Title);
+    assertNotCapitalization("Compare With Latest Version", Nls.Capitalization.Title);
     assertNotCapitalization("Compare with", Nls.Capitalization.Title);
-  }
-
-  public void testPunctuationSingleSentenceNoPeriod() {
-    assertTrue("Single sentence should not have period", checkPunctuation("This is a single sentence"));
-  }
-
-  public void testPunctuationSingleSentenceWithPeriod() {
-    assertFalse("Single sentence should not end with period", checkPunctuation("This is a single sentence."));
-  }
-
-  public void testPunctuationMultipleSentencesWithPeriods() {
-    assertTrue("Multiple sentences should end with periods", checkPunctuation("First sentence. Second sentence."));
-  }
-
-  public void testPunctuationMultipleSentencesWithoutFinalPeriod() {
-    assertFalse("Multiple sentences should end with periods", checkPunctuation("First sentence. Second sentence"));
-  }
-
-  public void testPunctuationNoDoubleQuotes() {
-    assertFalse("Should not use double quotes", checkPunctuation("This is \"quoted\" text"));
-  }
-
-  public void testPunctuationSingleQuotesAllowed() {
-    assertTrue("Single quotes are allowed", checkPunctuation("This is 'quoted' text"));
-  }
-
-  public void testPunctuationNoExclamation() {
-    assertFalse("Should not use exclamation points", checkPunctuation("This is important!"));
-  }
-
-  public void testPunctuationNoContractions() {
-    assertFalse("Should not use contractions", checkPunctuation("Path can't be found"));
-  }
-
-  public void testPunctuationDontAgainAllowed() {
-    assertTrue("'Don't [verb] again' is allowed", checkPunctuation("Don't ask again"));
+    assertNotCapitalization("Save Current Layout As New", Nls.Capitalization.Title);
+    assertNotCapitalization("Compare with…", Nls.Capitalization.Title);
+    assertNotCapitalization("Open in…", Nls.Capitalization.Title);
   }
 
   public void testFixValueTitleWithArticles() {

platform/util/src/com/intellij/openapi/util/text/StringUtil.java

@@ -457,14 +457,22 @@ public static int difference(@NotNull String s1, @NotNull String s2) {
               // special string like ~java or _java; keep it as is
               continue;
             }
-            if (!isPreposition(s, start, i - 1, ourOtherNonCapitalizableWords)) {
-              boolean firstWord = start == 0 || isPunctuation(prevPrevChar);
-              boolean lastWord = i >= length - 1|| isPunctuation(s.charAt(i + 1));
-              if (!title || firstWord || lastWord || !isPreposition(s, start, i - 1, wordsToIgnore)) {
-                if (buffer == null) {
-                  buffer = new StringBuilder(s);
-                }
-                buffer.setCharAt(start, title ? toUpperCase(currChar) : toLowerCase(currChar));
+
+            if (!isPreposition(s, start, i - 1, ourOtherNonCapitalizableWords)) {  // keep unchanged special words
+              if (buffer == null) {
+                buffer = new StringBuilder(s);
+              }
+
+              if (!title) {
+                buffer.setCharAt(start, toLowerCase(currChar));
+              }
+              else {
+                boolean firstWord = start == 0 || isPunctuation(prevPrevChar);
+                boolean lastWord = i >= length - 1|| isPunctuation(s.charAt(i + 1));
+                // Prepositions may occur in both upper/lower case in Title capitalization:
+                // Example: Compare with the Latest Repository Version In…
+                buffer.setCharAt(start, firstWord || lastWord || !isPreposition(s, start, i - 1, wordsToIgnore)
+                                        ? toUpperCase(currChar) : toLowerCase(currChar));
               }
             }
           }
@@ -475,7 +483,7 @@ public static int difference(@NotNull String s1, @NotNull String s2) {
   }
 
   private static boolean isPunctuation(char c) {
-    return c == '.' || c == '!' || c == ':' || c == '?';
+    return c == '.' || c == '!' || c == ':' || c == '?' || c == '…';
   }
 
   private static final String[] ourLowerCaseWords = {

plugins/devkit/intellij.devkit.i18n/testData/inspections/pluginXmlCapitalization/MyBundle.properties

@@ -15,11 +15,11 @@ group.BundleGroup.description=Bundle group description
 group.BundleGroupWrongCasing.text=group lower case text
 group.BundleGroupWrongCasing.description=group lower case description
 
-action.OverrideBundleAction.ViaBundle.text=Action Text Override Via Bundle
+action.OverrideBundleAction.ViaBundle.text=Action Text Override via Bundle
 action.OverrideBundleAction.ViaBundleWrongCase.text=Action Text Override Via Bundle lower case
 
 group.OverrideGroup.text=Group Text
-group.OverrideGroup.GroupViaBundle.text=Group Via Bundle Text
+group.OverrideGroup.GroupViaBundle.text=Group via Bundle Text
 group.OverrideGroup.GroupViaBundleWrongCase.text=override group wrong case
 
 titleCaseKey=My Text