feat: bind snake case name methods along with original method .net to python

Author: jhonabreul

src/embed_tests/ClassManagerTests.cs

@@ -24,6 +24,39 @@ public void NestedClassDerivingFromParent()
             var f = new NestedTestContainer().ToPython();
             f.GetAttr(nameof(NestedTestContainer.Bar));
         }
+
+        #region Snake case naming tests
+
+        public class SnakeCaseNamesTesClass
+        {
+            // Purposely long method name to test snake case conversion
+            public int AddNumbersAndGetHalf(int a, int b)
+            {
+                return (a + b) / 2;
+            }
+
+            public static int AddNumbersAndGetHalf_Static(int a, int b)
+            {
+                return (a + b) / 2;
+            }
+        }
+
+        [TestCase("AddNumbersAndGetHalf", "add_numbers_and_get_half")]
+        [TestCase("AddNumbersAndGetHalf_Static", "add_numbers_and_get_half_static")]
+        public void BindsSnakeCaseClassMethods(string originalMethodName, string snakeCaseMethodName)
+        {
+            using var obj = new SnakeCaseNamesTesClass().ToPython();
+            using var a = 10.ToPython();
+            using var b = 20.ToPython();
+
+            var camelCaseResult = obj.InvokeMethod(originalMethodName, a, b).As<int>();
+            var snakeCaseResult = obj.InvokeMethod(snakeCaseMethodName, a, b).As<int>();
+
+            Assert.AreEqual(15, camelCaseResult);
+            Assert.AreEqual(camelCaseResult, snakeCaseResult);
+        }
+
+        #endregion
     }
 
     public class NestedTestParent

src/embed_tests/TestUtil.cs

@@ -0,0 +1,23 @@
+using NUnit.Framework;
+
+using Python.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    [TestFixture]
+    public class TestUtil
+    {
+        [TestCase("TestCamelCaseString", "test_camel_case_string")]
+        [TestCase("testCamelCaseString", "test_camel_case_string")]
+        [TestCase("TestCamelCaseString123 ", "test_camel_case_string123")]
+        [TestCase("_testCamelCaseString123", "_test_camel_case_string123")]
+        [TestCase("TestCCS", "test_ccs")]
+        [TestCase("testCCS", "test_ccs")]
+        [TestCase("CCSTest", "ccs_test")]
+        [TestCase("test_CamelCaseString", "test_camel_case_string")]
+        public void ConvertsNameToSnakeCase(string name, string expected)
+        {
+            Assert.AreEqual(expected, name.ToSnakeCase());
+        }
+    }
+}

src/runtime/ClassManager.cs

@@ -448,11 +448,21 @@ private static ClassInfo GetClassInfo(Type type, ClassBase impl)
                         if (name == "__init__" && !impl.HasCustomNew())
                             continue;
 
-                        if (!methods.TryGetValue(name, out var methodList))
+                        List<MethodBase> methodList;
+                        var names = new List<string> { name };
+                        if (!meth.IsSpecialName && !OperatorMethod.IsOperatorMethod(meth))
                         {
-                            methodList = methods[name] = new List<MethodBase>();
+                            names.Add(name.ToSnakeCase());
+                        }
+                        foreach (var currentName in names.Distinct())
+                        {
+                            if (!methods.TryGetValue(currentName, out methodList))
+                            {
+                                methodList = methods[currentName] = new List<MethodBase>();
+                            }
+                            methodList.Add(meth);
                         }
-                        methodList.Add(meth);
+
                         continue;
 
                     case MemberTypes.Constructor when !impl.HasCustomNew():

src/runtime/Util/Util.cs

@@ -1,10 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
-using System.Diagnostics.Contracts;
+using System.Globalization;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Text;
 
 namespace Python.Runtime
 {
@@ -158,5 +159,68 @@ public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> source)
                 if (item is not null) yield return item;
             }
         }
+
+        /// <summary>
+        /// Converts the specified name to snake case.
+        /// </summary>
+        /// <remarks>
+        /// Reference: https://github.com/efcore/EFCore.NamingConventions/blob/main/EFCore.NamingConventions/Internal/SnakeCaseNameRewriter.cs
+        /// </remarks>
+        public static string ToSnakeCase(this string name)
+        {
+            var builder = new StringBuilder(name.Length + Math.Min(2, name.Length / 5));
+            var previousCategory = default(UnicodeCategory?);
+
+            for (var currentIndex = 0; currentIndex < name.Length; currentIndex++)
+            {
+                var currentChar = name[currentIndex];
+                if (currentChar == '_')
+                {
+                    builder.Append('_');
+                    previousCategory = null;
+                    continue;
+                }
+
+                var currentCategory = char.GetUnicodeCategory(currentChar);
+                switch (currentCategory)
+                {
+                    case UnicodeCategory.UppercaseLetter:
+                    case UnicodeCategory.TitlecaseLetter:
+                        if (previousCategory == UnicodeCategory.SpaceSeparator ||
+                            previousCategory == UnicodeCategory.LowercaseLetter ||
+                            previousCategory != UnicodeCategory.DecimalDigitNumber &&
+                            previousCategory != null &&
+                            currentIndex > 0 &&
+                            currentIndex + 1 < name.Length &&
+                            char.IsLower(name[currentIndex + 1]))
+                        {
+                            builder.Append('_');
+                        }
+
+                        currentChar = char.ToLower(currentChar, CultureInfo.InvariantCulture);
+                        break;
+
+                    case UnicodeCategory.LowercaseLetter:
+                    case UnicodeCategory.DecimalDigitNumber:
+                        if (previousCategory == UnicodeCategory.SpaceSeparator)
+                        {
+                            builder.Append('_');
+                        }
+                        break;
+
+                    default:
+                        if (previousCategory != null)
+                        {
+                            previousCategory = UnicodeCategory.SpaceSeparator;
+                        }
+                        continue;
+                }
+
+                builder.Append(currentChar);
+                previousCategory = currentCategory;
+            }
+
+            return builder.ToString();
+        }
     }
 }