Adding Proper Snake Case for issue efcore#151

EFCore.NamingConventions.Test/NamingConventionsOptionsExtensionTest.cs

@@ -35,6 +35,7 @@ public static IEnumerable<object[]> Convention()
             NamingConvention.CamelCase => new NamingConventionsOptionsExtension().WithCamelCaseNamingConvention(),
             NamingConvention.UpperCase => new NamingConventionsOptionsExtension().WithUpperCaseNamingConvention(),
             NamingConvention.UpperSnakeCase => new NamingConventionsOptionsExtension().WithUpperSnakeCaseNamingConvention(),
+            NamingConvention.ProperSnakeCase => new NamingConventionsOptionsExtension().WithProperSnakeCaseNamingConvention(),
             _ => throw new ArgumentOutOfRangeException($"Unhandled enum value: {convention}, NamingConventionsOptionsExtension not defined for the test")
         };
     }

EFCore.NamingConventions.Test/RewriterTest.cs

@@ -25,4 +25,8 @@ public void Camel_case()
     [Fact]
     public void Upper_case()
         => Assert.Equal("FULLNAME", new UpperCaseNameRewriter(CultureInfo.InvariantCulture).RewriteName("FullName"));
+
+    [Fact]
+    public void Proper_snake_case()
+        => Assert.Equal("Full_Name", new ProperSnakeCaseNameRewriter(CultureInfo.InvariantCulture).RewriteName("FullName"));
 }

EFCore.NamingConventions/Internal/NamingConvention.cs

@@ -7,5 +7,6 @@ public enum NamingConvention
     LowerCase,
     CamelCase,
     UpperCase,
-    UpperSnakeCase
+    UpperSnakeCase,
+    ProperSnakeCase
 }

EFCore.NamingConventions/Internal/NamingConventionSetPlugin.cs

@@ -38,6 +38,7 @@ public ConventionSet ModifyConventions(ConventionSet conventionSet)
             NamingConvention.CamelCase => new CamelCaseNameRewriter(culture ?? CultureInfo.InvariantCulture),
             NamingConvention.UpperCase => new UpperCaseNameRewriter(culture ?? CultureInfo.InvariantCulture),
             NamingConvention.UpperSnakeCase => new UpperSnakeCaseNameRewriter(culture ?? CultureInfo.InvariantCulture),
+            NamingConvention.ProperSnakeCase => new ProperSnakeCaseNameRewriter(culture ?? CultureInfo.InvariantCulture),
             _ => throw new ArgumentOutOfRangeException("Unhandled enum value: " + namingStyle)
         });
 

EFCore.NamingConventions/Internal/NamingConventionsOptionsExtension.cs

@@ -74,6 +74,14 @@ public virtual NamingConventionsOptionsExtension WithCamelCaseNamingConvention(C
         return clone;
     }
 
+    public virtual NamingConventionsOptionsExtension WithProperSnakeCaseNamingConvention(CultureInfo? culture = null)
+    {
+        var clone = Clone();
+        clone._namingConvention = NamingConvention.ProperSnakeCase;
+        clone._culture = culture;
+        return clone;
+    }
+
     public void Validate(IDbContextOptions options) {}
 
     public void ApplyServices(IServiceCollection services)
@@ -106,6 +114,7 @@ public override string LogFragment
                         NamingConvention.UpperCase => "using upper case naming",
                         NamingConvention.UpperSnakeCase => "using upper snake-case naming",
                         NamingConvention.CamelCase => "using camel-case naming",
+                        NamingConvention.ProperSnakeCase => "using proper snake-case naming",
                         _ => throw new ArgumentOutOfRangeException("Unhandled enum value: " + Extension._namingConvention)
                     });
 

EFCore.NamingConventions/Internal/ProperSnakeCaseNameRewriter.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace EFCore.NamingConventions.Internal;
+
+public class ProperSnakeCaseNameRewriter : SnakeCaseNameRewriter
+{
+    private readonly CultureInfo _culture;
+
+    public ProperSnakeCaseNameRewriter(CultureInfo culture) : base(culture)
+        => _culture = culture;
+
+    public override string RewriteName(string name)
+    {
+        if (string.IsNullOrEmpty(name))
+        {
+            return name;
+        }
+
+        name = base.RewriteName(name);
+
+        var arr = name.ToCharArray();
+        var shouldCapitalizeNext = true;
+
+        for (var i = 0; i < arr.Length; i++)
+        {
+            if (arr[i] == '_')
+            {
+                shouldCapitalizeNext = true;
+            }
+            else if (shouldCapitalizeNext)
+            {
+                arr[i] = char.ToUpper(arr[i]);
+                shouldCapitalizeNext = false;
+            }
+        }
+
+        return new(arr);
+    }
+}

EFCore.NamingConventions/NamingConventionsExtensions.cs

@@ -111,4 +111,25 @@ public static DbContextOptionsBuilder<TContext> UseCamelCaseNamingConvention<TCo
         CultureInfo? culture = null)
         where TContext : DbContext
         => (DbContextOptionsBuilder<TContext>)UseCamelCaseNamingConvention((DbContextOptionsBuilder)optionsBuilder, culture);
+
+    public static DbContextOptionsBuilder UseProperSnakeCaseNamingConvention(
+        this DbContextOptionsBuilder optionsBuilder,
+        CultureInfo? culture = null)
+    {
+        Check.NotNull(optionsBuilder, nameof(optionsBuilder));
+
+        var extension = (optionsBuilder.Options.FindExtension<NamingConventionsOptionsExtension>()
+                ?? new NamingConventionsOptionsExtension())
+            .WithProperSnakeCaseNamingConvention(culture);
+
+        ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(extension);
+
+        return optionsBuilder;
+    }
+
+    public static DbContextOptionsBuilder<TContext> UseProperSnakeCaseNamingConvention<TContext>(
+        this DbContextOptionsBuilder<TContext> optionsBuilder,
+        CultureInfo? culture = null)
+        where TContext : DbContext
+        => (DbContextOptionsBuilder<TContext>)UseProperSnakeCaseNamingConvention((DbContextOptionsBuilder)optionsBuilder, culture);
 }