Added tests for the additions to NameHelpers.UnderscoresToXxxxxCase

src/ProtocolBuffers.Test/NameHelpersTest.cs

@@ -48,6 +48,11 @@ namespace Google.ProtocolBuffers
             Assert.AreEqual("FooBar", NameHelpers.UnderscoresToPascalCase("foo_bar"));
             Assert.AreEqual("Foo0Bar", NameHelpers.UnderscoresToPascalCase("Foo0bar"));
             Assert.AreEqual("FooBar", NameHelpers.UnderscoresToPascalCase("Foo_+_Bar"));
+
+            Assert.AreEqual("Bar", NameHelpers.UnderscoresToPascalCase("__+bar"));
+            Assert.AreEqual("Bar", NameHelpers.UnderscoresToPascalCase("bar_"));
+            Assert.AreEqual("_0Bar", NameHelpers.UnderscoresToPascalCase("_0bar"));
+            Assert.AreEqual("_1Bar", NameHelpers.UnderscoresToPascalCase("_1_bar"));
         }
 
         [Test]
@@ -57,6 +62,11 @@ namespace Google.ProtocolBuffers
             Assert.AreEqual("fooBar", NameHelpers.UnderscoresToCamelCase("foo_bar"));
             Assert.AreEqual("foo0Bar", NameHelpers.UnderscoresToCamelCase("Foo0bar"));
             Assert.AreEqual("fooBar", NameHelpers.UnderscoresToCamelCase("Foo_+_Bar"));
+
+            Assert.AreEqual("bar", NameHelpers.UnderscoresToCamelCase("__+bar"));
+            Assert.AreEqual("bar", NameHelpers.UnderscoresToCamelCase("bar_"));
+            Assert.AreEqual("_0Bar", NameHelpers.UnderscoresToCamelCase("_0bar"));
+            Assert.AreEqual("_1Bar", NameHelpers.UnderscoresToCamelCase("_1_bar"));
         }
 
         [Test]

src/ProtocolBuffers/NameHelpers.cs

@@ -48,37 +48,45 @@ namespace Google.ProtocolBuffers
     {
         public static string UnderscoresToPascalCase(string input)
         {
-            return UnderscoresToPascalOrCamelCase(input, true);
+            string name = UnderscoresToUpperCase(input);
+
+            // Pascal case always begins with upper-case letter
+            if (Char.IsLower(name[0]))
+            {
+                char[] chars = name.ToCharArray();
+                chars[0] = char.ToUpper(chars[0]);
+                return new string(chars);
+            }
+            return name;
         }
 
         public static string UnderscoresToCamelCase(string input)
         {
-            return UnderscoresToPascalOrCamelCase(input, false);
+            string name = UnderscoresToUpperCase(input);
+
+            // Camel case always begins with lower-case letter
+            if (Char.IsUpper(name[0]))
+            {
+                char[] chars = name.ToCharArray();
+                chars[0] = char.ToLower(chars[0]);
+                return new string(chars);
+            }
+            return name;
         }
 
         /// <summary>
-        /// Converts a string to Pascal or Camel case. The first letter is capitalized or
-        /// lower-cased depending on <paramref name="pascal"/> is true. 
-        /// After the first letter, any punctuation is removed but triggers capitalization
-        /// of the next letter. Digits are preserved but trigger capitalization of the next
-        /// letter.
-        /// All capitalisation is done in the invariant culture. 
+        /// Capitalizes any characters following an '_' or a number '0' - '9' and removes
+        /// all non alpha-numberic characters.  If the resulting string begins with a number
+        /// an '_' will be prefixed.  
         /// </summary>
-        private static string UnderscoresToPascalOrCamelCase(string input, bool pascal)
+        private static string UnderscoresToUpperCase(string input)
         {
-            string name = Transform(input, pascal ? UnderlineToPascal : UnderlineToCamel, x => x.Value.TrimStart('_').ToUpper());
+            string name = Transform(input, UnderlineCharacter, x => x.Value.ToUpper());
+            name = Transform(name, InvalidCharacters, x => String.Empty);
 
             if (name.Length == 0)
                 throw new ArgumentException(String.Format("The field name '{0}' is invalid.", input));
 
-            // Pascal case always begins with lower-case letter
-            if (!pascal && Char.IsUpper(name[0]))
-            {
-                char[] chars = name.ToCharArray();
-                chars[0] = char.ToLower(chars[0]);
-                return new string(chars);
-            }
-
             // Fields can not start with a number
             if (Char.IsNumber(name[0]))
                 name = '_' + name;
@@ -110,14 +118,14 @@ namespace Google.ProtocolBuffers
         }
 
         /// <summary>
-        /// Similar to UnderlineToCamel, but also matches the first character if it is lower-case
+        /// All characters that are not alpha-numberic
         /// </summary>
-        private static Regex UnderlineToPascal = new Regex(@"(?:(?:^|[0-9_])[a-z])|_");
+        private static Regex InvalidCharacters = new Regex(@"[^a-zA-Z0-9]+");
 
         /// <summary>
         /// Matches lower-case character that follow either an underscore, or a number
         /// </summary>
-        private static Regex UnderlineToCamel = new Regex(@"(?:[0-9_][a-z])|_");
+        private static Regex UnderlineCharacter = new Regex(@"[0-9_][a-z]");
 
         /// <summary>
         /// Used for text-template transformation where a regex match is replaced in the input string.