Rewrite and more tests, and keep fully backwards compatible

Author: davidwengier

src/Compiler/Microsoft.AspNetCore.Razor.Language/test/HtmlConventionsTest.cs

@@ -3,13 +3,15 @@
 
 #nullable disable
 
+using System;
+using System.Text.RegularExpressions;
 using Xunit;
 
 namespace Microsoft.AspNetCore.Razor.Language;
 
 public class HtmlConventionsTest
 {
-    public static TheoryData HtmlConversionData
+    public static TheoryData<string, string> HtmlConversionData
     {
         get
         {
@@ -21,12 +23,21 @@ public static TheoryData HtmlConversionData
                     { "CAPSOnOUTSIDE", "caps-on-outside" },
                     { "ALLCAPS", "allcaps" },
                     { "One1Two2Three3", "one1-two2-three3" },
-                    { "ONE1TWO2THREE3", "one1-two2-three3" },
-                    { "First_Second_ThirdHi", "first_second_third-hi" }
+                    { "ONE1TWO2THREE3", "one1two2three3" },
+                    { "First_Second_ThirdHi", "first_second_third-hi" },
+                    { "One123Two234Three345", "one123-two234-three345" },
+                    { "ONE123TWO234THREE345", "one123two234three345" },
+                    { "1TWO2THREE3", "1two2three3" },
+                    { "alllowercase", "alllowercase" },
                 };
         }
     }
 
+    private static readonly Regex OldHtmlCaseRegex = new Regex(
+        "(?<!^)((?<=[a-zA-Z0-9])[A-Z][a-z])|((?<=[a-z])[A-Z])",
+        RegexOptions.None,
+        TimeSpan.FromMilliseconds(500));
+
     [Theory]
     [MemberData(nameof(HtmlConversionData))]
     public void ToHtmlCase_ReturnsExpectedConversions(string input, string expectedOutput)
@@ -36,5 +47,9 @@ public void ToHtmlCase_ReturnsExpectedConversions(string input, string expectedO
 
         // Assert
         Assert.Equal(expectedOutput, output);
+
+        // Assure backwards compatibility with regex
+        var regexResult = OldHtmlCaseRegex.Replace(input, "-$1$2").ToLowerInvariant();
+        Assert.Equal(regexResult, output);
     }
 }

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/HtmlConventions.cs

@@ -1,9 +1,9 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-#nullable disable
-
 using System;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.AspNetCore.Razor.PooledObjects;
 
 namespace Microsoft.AspNetCore.Razor.Language;
@@ -38,49 +38,81 @@ internal static bool IsInvalidNonWhitespaceHtmlCharacters(char testChar)
     /// ONE1TWO2THREE3 => one1two2three3
     /// First_Second_ThirdHi => first_second_third-hi
     /// </example>
-    public static string ToHtmlCase(string name)
+    public static string ToHtmlCase(string input)
     {
-        if (string.IsNullOrEmpty(name))
+        if (string.IsNullOrEmpty(input))
         {
-            return name;
+            return input;
         }
 
-        var input = name.AsSpan();
+        return TryGetKebabCaseString(input, out var result)
+            ? result
+            : input;
+    }
 
-        using var _ = StringBuilderPool.GetPooledObject(out var result);
-        result.SetCapacityIfLarger(input.Length + 5);
+    private static bool TryGetKebabCaseString(ReadOnlySpan<char> input, [NotNullWhen(true)] out string? result)
+    {
+        using var _ = StringBuilderPool.GetPooledObject(out var builder);
 
-        // It's slightly faster to use a foreach and index manually, than to use a for 🤷‍
+        var allLower = true;
         var i = 0;
-        foreach (var c in name)
+        foreach (var c in input)
         {
             if (char.IsUpper(c))
             {
-                // Insert hyphen if:
-                // - Not the first character, and
-                // - Previous is lowercase or digit, or
-                // - Previous is uppercase and next is lowercase (e.g. CAPSOn → caps-on)
-                if (i > 0)
+                allLower = false;
+
+                if (ShouldInsertHyphenBeforeUppercase(input, i))
                 {
-                    var prev = input[i - 1];
-                    var prevIsLowerOrDigit = char.IsLower(prev) || char.IsDigit(prev);
-                    var prevIsUpper = char.IsUpper(prev);
-                    var nextIsLower = (i + 1 < input.Length) && char.IsLower(input[i + 1]);
-                    if (prevIsLowerOrDigit || (prevIsUpper && nextIsLower))
-                    {
-                        result.Append('-');
-                    }
+                    builder.Append('-');
                 }
-                result.Append(char.ToLowerInvariant(c));
+
+                builder.Append(char.ToLowerInvariant(c));
             }
             else
             {
-                result.Append(c);
+                builder.Append(c);
             }
 
             i++;
         }
 
-        return result.ToString();
+        if (allLower)
+        {
+            // If the input is all lowercase, we don't need to realize the builder,
+            // it will just be cleared when the pooled object is disposed.
+            result = null;
+            return false;
+        }
+
+        result = builder.ToString();
+        return true;
+    }
+
+    private static bool ShouldInsertHyphenBeforeUppercase(ReadOnlySpan<char> input, int i)
+    {
+        Debug.Assert(char.IsUpper(input[i]));
+
+        if (i == 0)
+        {
+            // First character is uppercase, no hyphen needed (e.g. This → this)
+            return false;
+        }
+
+        var prev = input[i - 1];
+        if (char.IsLower(prev))
+        {
+            // Lowercase followed by uppercase (e.g. someThing → some-thing)
+            return true;
+        }
+
+        if ((char.IsUpper(prev) || char.IsDigit(prev)) &&
+            (i + 1 < input.Length) && char.IsLower(input[i + 1]))
+        {
+            // Uppercase or digit followed by lowercase (e.g. CAPSOn → caps-on)
+            return true; ;
+        }
+
+        return false;
     }
 }