fix: camel to camel and snake to snake

ExerciseBook · ExerciseBook · commit ee5f3a449064 · 2024-06-08T13:47:50.000+08:00
diff --git a/OneBot-Interface/Core/Util/StringUtils.cs b/OneBot-Interface/Core/Util/StringUtils.cs
@@ -16,16 +16,34 @@ public enum CamelCaseType
     {
         Upper,
 
-        Lower
+        Lower,
+
+        None,
     }
 
     public enum CaseType
     {
         Lower,
 
-        Upper
+        Upper,
+
+        None,
     }
 
+    private static CaseType EvaluateCaseType(char c)
+    {
+        if (char.IsUpper(c))
+        {
+            return CaseType.Upper;
+        }
+
+        if (char.IsLower(c))
+        {
+            return CaseType.Lower;
+        }
+
+        return CaseType.None;
+    }
 
     public static bool IsNullOrEmpty(string? value)
         => string.IsNullOrEmpty(value);
@@ -80,9 +98,14 @@ public static string ToCamelCase(string s, CamelCaseType caseType, string[]? loc
         char[] result = new char[src.Length - ulCnt];
         bool fstWord = true, fstLetter = true;
         string tmp = "";
+
         for (int i = 0, j = 0; i <= src.Length; i++)
         {
-            if (i == src.Length || src[i] == Underline || src[i] == Dash || char.IsSeparator(src[i]))
+            if (i == src.Length ||
+                src[i] == Underline || src[i] == Dash ||
+                char.IsSeparator(src[i]) ||
+                (i > 0 && char.IsUpper(src[i]))
+               )
             {
                 if (lockedWords != null && lockedWords.Contains(tmp))
                 {
@@ -95,13 +118,21 @@ public static string ToCamelCase(string s, CamelCaseType caseType, string[]? loc
                             result[j - tmp.Length + k] = char.ToLower(result[j - tmp.Length + k]);
                     }
                 }
+
                 if (i < src.Length)
                 {
                     if (src[i] == Underline || src[i] == Dash)
                     {
                         fstLetter = true;
                         tmp = "";
                     }
+                    else if  (i > 0 && char.IsUpper(src[i]))
+                    {
+                        fstLetter = false;
+                        result[j] = src[i];
+                        tmp = "" + src[i];
+                        j++;
+                    }
                     else
                     {
                         fstWord = true;
@@ -128,6 +159,7 @@ public static string ToCamelCase(string s, CamelCaseType caseType, string[]? loc
                 {
                     result[j] = char.ToLower(src[i]);
                 }
+
                 tmp += char.ToUpper(src[i]);
                 j++;
             }
@@ -164,20 +196,31 @@ public static string ToUpperSnakeCase(string s, string[]? lockedWords = null)
     /// <returns></returns>
     public static string ToSeparatedCase(string s, char separator, CaseType caseType, string[]? lockedWords = null)
     {
-        StringBuilder sb = new StringBuilder();
+        StringBuilder sb = new StringBuilder(16);
         char[] src = s.ToCharArray();
-        
+
         int t = 0;
+        var separated = false;
+
         for (int i = 0; i < src.Length; i++, t++)
         {
+
             if (char.IsSeparator(src[i]))
             {
                 sb.Append(src[i]);
                 t = -1;
                 continue;
             }
-            if (char.IsUpper(src[i]))
+
+            if (src[i] == Dash || src[i] == Underline)
+            {
+                separated = true;
+                continue;
+            }
+
+            if (separated || char.IsUpper(src[i]))
             {
+                separated = false;
                 if (lockedWords != null)
                 {
                     bool skip = false;
@@ -192,6 +235,7 @@ public static string ToSeparatedCase(string s, char separator, CaseType caseType
                                 break;
                             }
                         }
+
                         if (match)
                         {
                             if (t != 0)
@@ -204,21 +248,29 @@ public static string ToSeparatedCase(string s, char separator, CaseType caseType
                                     sb.Append(char.ToLower(src[i]));
                                 i++;
                             }
+
                             i--;
                             skip = true;
                             break;
                         }
                     }
+
                     if (skip)
                         continue;
                 }
+
                 if (t != 0)
                     sb.Append(separator);
             }
+
             if (caseType == CaseType.Upper)
+            {
                 sb.Append(char.ToUpper(src[i]));
+            }
             else
+            {
                 sb.Append(char.ToLower(src[i]));
+            }
         }
 
         return sb.ToString();
diff --git a/OneBot-UnitTest/UnitTest/Util/StringUtilsTest.cs b/OneBot-UnitTest/UnitTest/Util/StringUtilsTest.cs
@@ -39,22 +39,33 @@ public void ToSnakeCaseTest()
         
         Assert.AreEqual("one_another", StringUtils.ToSnakeCase("oneAnother", StringUtils.CaseType.Lower, lockedWords));
         Assert.AreEqual("ONE_ANOTHER", StringUtils.ToSnakeCase("oneAnother", StringUtils.CaseType.Upper, lockedWords));
+        
+        Assert.AreEqual("ONE_ANOTHER", StringUtils.ToSnakeCase("one-Another", StringUtils.CaseType.Upper, lockedWords));
+        Assert.AreEqual("ONE_ANOTHER", StringUtils.ToSnakeCase("one_Another", StringUtils.CaseType.Upper, lockedWords));
+        Assert.AreEqual("ONE_ANOTHER", StringUtils.ToSnakeCase("one_-Another", StringUtils.CaseType.Upper, lockedWords));
     }
     
     [TestMethod]
     public void ToLowerCamelTest()
     {
         Assert.AreEqual("userQQ", StringUtils.ToCamelCase("user_qq", StringUtils.CamelCaseType.Lower, lockedWords));
+        Assert.AreEqual("userQQ", StringUtils.ToCamelCase("userQQ", StringUtils.CamelCaseType.Lower, lockedWords));
+        Assert.AreEqual("userQQ", StringUtils.ToCamelCase("userQq", StringUtils.CamelCaseType.Lower, lockedWords));
         Assert.AreEqual("userID", StringUtils.ToCamelCase("user_id", StringUtils.CamelCaseType.Lower, lockedWords));
         Assert.AreEqual("qqID", StringUtils.ToCamelCase("qq_id", StringUtils.CamelCaseType.Lower, lockedWords));
         Assert.AreEqual("icelolly", StringUtils.ToCamelCase("icelolly", StringUtils.CamelCaseType.Lower));
         Assert.AreEqual("icelolly", StringUtils.ToCamelCase("Icelolly", StringUtils.CamelCaseType.Lower));
-        Assert.AreEqual("icelolly", StringUtils.ToCamelCase("IceLOlly", StringUtils.CamelCaseType.Lower));
+        Assert.AreEqual("iceLOlly", StringUtils.ToCamelCase("IceLOlly", StringUtils.CamelCaseType.Lower));
         Assert.AreEqual("icelollyDress", StringUtils.ToCamelCase("icelolly_dress", StringUtils.CamelCaseType.Lower));
         Assert.AreEqual("icelollyDress2", StringUtils.ToCamelCase("icelolly_dress2", StringUtils.CamelCaseType.Lower));
-        Assert.AreEqual("icelollyDress", StringUtils.ToCamelCase("ICelolly_DRess", StringUtils.CamelCaseType.Lower));
-        Assert.AreEqual("icelollyDress daiSuki", StringUtils.ToCamelCase("iCelolly_dRess dai_suki", StringUtils.CamelCaseType.Lower));
-        Assert.AreEqual("icelollyDress daiSuki404", StringUtils.ToCamelCase("iCelolly_dRess dai_suki_404", StringUtils.CamelCaseType.Lower));
+        Assert.AreEqual("icelollyDress2", StringUtils.ToCamelCase("icelolly_dress_2", StringUtils.CamelCaseType.Lower));
+        
+        // ambiguous case, not supports
+        Assert.AreEqual("iCelollyDRess", StringUtils.ToCamelCase("ICelolly_DRess", StringUtils.CamelCaseType.Lower));
+        
+        Assert.AreEqual("iCelollyDRess daiSuki", StringUtils.ToCamelCase("iCelolly_dRess dai_suki", StringUtils.CamelCaseType.Lower));
+        Assert.AreEqual("iCelollyDRess daiSuki404", StringUtils.ToCamelCase("iCelolly_dRess dai_suki_404", StringUtils.CamelCaseType.Lower));
+        Assert.AreEqual("iCelollyDRess", StringUtils.ToCamelCase("iCelolly_----dRess", StringUtils.CamelCaseType.Lower));
     }
     
     [TestMethod]
@@ -65,11 +76,11 @@ public void ToUpperCamelTest()
         Assert.AreEqual("QQID", StringUtils.ToCamelCase("qq_id", StringUtils.CamelCaseType.Upper, lockedWords));
         Assert.AreEqual("Icelolly", StringUtils.ToCamelCase("icelolly", StringUtils.CamelCaseType.Upper));
         Assert.AreEqual("Icelolly", StringUtils.ToCamelCase("Icelolly", StringUtils.CamelCaseType.Upper));
-        Assert.AreEqual("Icelolly", StringUtils.ToCamelCase("IceLOlly", StringUtils.CamelCaseType.Upper));
+        Assert.AreEqual("IceLOlly", StringUtils.ToCamelCase("IceLOlly", StringUtils.CamelCaseType.Upper));
         Assert.AreEqual("IcelollyDress", StringUtils.ToCamelCase("icelolly_dress", StringUtils.CamelCaseType.Upper));
         Assert.AreEqual("IcelollyDress2", StringUtils.ToCamelCase("icelolly_dress2", StringUtils.CamelCaseType.Upper));
-        Assert.AreEqual("IcelollyDress", StringUtils.ToCamelCase("ICelolly_DRess", StringUtils.CamelCaseType.Upper));
-        Assert.AreEqual("IcelollyDress DaiSuki", StringUtils.ToCamelCase("iCelolly_dRess dai_suki", StringUtils.CamelCaseType.Upper));
-        Assert.AreEqual("IcelollyDress DaiSuki404", StringUtils.ToCamelCase("iCelolly_dRess dai_suki_404", StringUtils.CamelCaseType.Upper));
+        Assert.AreEqual("ICelollyDRess", StringUtils.ToCamelCase("ICelolly_DRess", StringUtils.CamelCaseType.Upper));
+        Assert.AreEqual("ICelollyDRess DaiSuki", StringUtils.ToCamelCase("iCelolly_dRess dai_suki", StringUtils.CamelCaseType.Upper));
+        Assert.AreEqual("ICelollyDRess DaiSuki404", StringUtils.ToCamelCase("iCelolly_dRess dai_suki_404", StringUtils.CamelCaseType.Upper));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -16,16 +16,34 @@ public enum CamelCaseType`
`16`	`16`	`{`
`17`	`17`	`Upper,`
`18`	`18`
`19`		`- Lower`
	`19`	`+ Lower,`
	`20`	`+`
	`21`	`+ None,`
`20`	`22`	`}`
`21`	`23`
`22`	`24`	`public enum CaseType`
`23`	`25`	`{`
`24`	`26`	`Lower,`
`25`	`27`
`26`		`- Upper`
	`28`	`+ Upper,`
	`29`	`+`
	`30`	`+ None,`
`27`	`31`	`}`
`28`	`32`
	`33`	`+ private static CaseType EvaluateCaseType(char c)`
	`34`	`+ {`
	`35`	`+ if (char.IsUpper(c))`
	`36`	`+ {`
	`37`	`+ return CaseType.Upper;`
	`38`	`+ }`
	`39`	`+`
	`40`	`+ if (char.IsLower(c))`
	`41`	`+ {`
	`42`	`+ return CaseType.Lower;`
	`43`	`+ }`
	`44`	`+`
	`45`	`+ return CaseType.None;`
	`46`	`+ }`
`29`	`47`
`30`	`48`	`public static bool IsNullOrEmpty(string? value)`
`31`	`49`	`=> string.IsNullOrEmpty(value);`
`@@ -80,9 +98,14 @@ public static string ToCamelCase(string s, CamelCaseType caseType, string[]? loc`
`80`	`98`	`char[] result = new char[src.Length - ulCnt];`
`81`	`99`	`bool fstWord = true, fstLetter = true;`
`82`	`100`	`string tmp = "";`
	`101`	`+`
`83`	`102`	`for (int i = 0, j = 0; i <= src.Length; i++)`
`84`	`103`	`{`
`85`		`- if (i == src.Length \|\| src[i] == Underline \|\| src[i] == Dash \|\| char.IsSeparator(src[i]))`
	`104`	`+ if (i == src.Length \|\|`
	`105`	`+ src[i] == Underline \|\| src[i] == Dash \|\|`
	`106`	`+ char.IsSeparator(src[i]) \|\|`
	`107`	`+ (i > 0 && char.IsUpper(src[i]))`
	`108`	`+ )`
`86`	`109`	`{`
`87`	`110`	`if (lockedWords != null && lockedWords.Contains(tmp))`
`88`	`111`	`{`
`@@ -95,13 +118,21 @@ public static string ToCamelCase(string s, CamelCaseType caseType, string[]? loc`
`95`	`118`	`result[j - tmp.Length + k] = char.ToLower(result[j - tmp.Length + k]);`
`96`	`119`	`}`
`97`	`120`	`}`
	`121`	`+`
`98`	`122`	`if (i < src.Length)`
`99`	`123`	`{`
`100`	`124`	`if (src[i] == Underline \|\| src[i] == Dash)`
`101`	`125`	`{`
`102`	`126`	`fstLetter = true;`
`103`	`127`	`tmp = "";`
`104`	`128`	`}`
	`129`	`+ else if (i > 0 && char.IsUpper(src[i]))`
	`130`	`+ {`
	`131`	`+ fstLetter = false;`
	`132`	`+ result[j] = src[i];`
	`133`	`+ tmp = "" + src[i];`
	`134`	`+ j++;`
	`135`	`+ }`
`105`	`136`	`else`
`106`	`137`	`{`
`107`	`138`	`fstWord = true;`
`@@ -128,6 +159,7 @@ public static string ToCamelCase(string s, CamelCaseType caseType, string[]? loc`
`128`	`159`	`{`
`129`	`160`	`result[j] = char.ToLower(src[i]);`
`130`	`161`	`}`
	`162`	`+`
`131`	`163`	`tmp += char.ToUpper(src[i]);`
`132`	`164`	`j++;`
`133`	`165`	`}`
`@@ -164,20 +196,31 @@ public static string ToUpperSnakeCase(string s, string[]? lockedWords = null)`
`164`	`196`	`/// <returns></returns>`
`165`	`197`	`public static string ToSeparatedCase(string s, char separator, CaseType caseType, string[]? lockedWords = null)`
`166`	`198`	`{`
`167`		`- StringBuilder sb = new StringBuilder();`
	`199`	`+ StringBuilder sb = new StringBuilder(16);`
`168`	`200`	`char[] src = s.ToCharArray();`
`169`		`-`
	`201`	`+`
`170`	`202`	`int t = 0;`
	`203`	`+ var separated = false;`
	`204`	`+`
`171`	`205`	`for (int i = 0; i < src.Length; i++, t++)`
`172`	`206`	`{`
	`207`	`+`
`173`	`208`	`if (char.IsSeparator(src[i]))`
`174`	`209`	`{`
`175`	`210`	`sb.Append(src[i]);`
`176`	`211`	`t = -1;`
`177`	`212`	`continue;`
`178`	`213`	`}`
`179`		`- if (char.IsUpper(src[i]))`
	`214`	`+`
	`215`	`+ if (src[i] == Dash \|\| src[i] == Underline)`
	`216`	`+ {`
	`217`	`+ separated = true;`
	`218`	`+ continue;`
	`219`	`+ }`
	`220`	`+`
	`221`	`+ if (separated \|\| char.IsUpper(src[i]))`
`180`	`222`	`{`
	`223`	`+ separated = false;`
`181`	`224`	`if (lockedWords != null)`
`182`	`225`	`{`
`183`	`226`	`bool skip = false;`
`@@ -192,6 +235,7 @@ public static string ToSeparatedCase(string s, char separator, CaseType caseType`
`192`	`235`	`break;`
`193`	`236`	`}`
`194`	`237`	`}`
	`238`	`+`
`195`	`239`	`if (match)`
`196`	`240`	`{`
`197`	`241`	`if (t != 0)`
`@@ -204,21 +248,29 @@ public static string ToSeparatedCase(string s, char separator, CaseType caseType`
`204`	`248`	`sb.Append(char.ToLower(src[i]));`
`205`	`249`	`i++;`
`206`	`250`	`}`
	`251`	`+`
`207`	`252`	`i--;`
`208`	`253`	`skip = true;`
`209`	`254`	`break;`
`210`	`255`	`}`
`211`	`256`	`}`
	`257`	`+`
`212`	`258`	`if (skip)`
`213`	`259`	`continue;`
`214`	`260`	`}`
	`261`	`+`
`215`	`262`	`if (t != 0)`
`216`	`263`	`sb.Append(separator);`
`217`	`264`	`}`
	`265`	`+`
`218`	`266`	`if (caseType == CaseType.Upper)`
	`267`	`+ {`
`219`	`268`	`sb.Append(char.ToUpper(src[i]));`
	`269`	`+ }`
`220`	`270`	`else`
	`271`	`+ {`
`221`	`272`	`sb.Append(char.ToLower(src[i]));`
	`273`	`+ }`
`222`	`274`	`}`
`223`	`275`
`224`	`276`	`return sb.ToString();`