Enhance setting renaming

src/GUI/RevEng.Shared/TableRenamer.cs

@@ -8,6 +8,8 @@ public class TableRenamer
 
         public string NewName { get; set; }
 
+        public string VariableName { get; set; }
+
         public List<ColumnNamer> Columns { get; set; }
     }
 }

src/GUI/ReverseEngineer20/ReverseEngineer/InflectorPluralizer.cs

@@ -1,14 +1,38 @@
 using Humanizer;
 using Microsoft.EntityFrameworkCore.Design;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace ReverseEngineer20.ReverseEngineer
 {
     public class InflectorPluralizer : IPluralizer
     {
+        private readonly Dictionary<string, string> _customCharacterPluralize;
+        private readonly Dictionary<string, string> _customCharacterSingularize;
+
+        public InflectorPluralizer(List<Schema> customReplacers = null)
+        {
+            if(customReplacers != null)
+            {
+                _customCharacterPluralize = customReplacers
+                    .SelectMany(x => x.Tables)
+                    .Where(x => !string.IsNullOrWhiteSpace(x.VariableName))
+                    .ToDictionary(key => key.Name.ToPascalCase(), value => value.VariableName);
+
+                _customCharacterSingularize = customReplacers
+                    .SelectMany(x => x.Tables)
+                    .Where(x => !string.IsNullOrWhiteSpace(x.NewName))
+                    .ToDictionary(key => key.Name.ToPascalCase(), value => value.NewName);
+            }
+        }
+
         public string Pluralize(string name)
         {
             if (name != null)
             {
+                if (_customCharacterPluralize?.ContainsKey(name) ?? false)
+                    return _customCharacterPluralize[name];
+
                 return name.Pluralize(inputIsKnownToBeSingular: false);
             }
             return name;
@@ -18,6 +42,9 @@ public string Singularize(string name)
         {
             if (name != null)
             {
+                if (_customCharacterSingularize?.ContainsKey(name) ?? false)
+                    return _customCharacterSingularize[name];
+
                 return name.Singularize(inputIsKnownToBePlural: false);
             }
             return name;

src/GUI/ReverseEngineer20/ReverseEngineer/ReplacingCandidateNamingService.cs

@@ -36,8 +36,8 @@ public override string GenerateCandidateIdentifier(DatabaseTable originalTable)
 
             if (schema.UseSchemaName)
             {
-                candidateStringBuilder.Append(ToPascalCase(originalTable.Schema));
-                candidateStringBuilder.Append(ToPascalCase(originalTable.Name));
+                candidateStringBuilder.Append(originalTable.Schema.ToPascalCase());
+                candidateStringBuilder.Append(originalTable.Name.ToPascalCase());
 
                 return candidateStringBuilder.ToString();
             }
@@ -50,7 +50,7 @@ public override string GenerateCandidateIdentifier(DatabaseTable originalTable)
 
                 if (string.IsNullOrWhiteSpace(newTableName))
                 {
-                    candidateStringBuilder.Append(ToPascalCase(originalTable.Name));
+                    candidateStringBuilder.Append(originalTable.Name.ToPascalCase());
 
                     return candidateStringBuilder.ToString();
                 }
@@ -120,7 +120,7 @@ public override string GetDependentEndCandidateNavigationPropertyName(IForeignKe
             {
                 if (schema.UseSchemaName)
                 {
-                    return ToPascalCase(schema.SchemaName) + baseName;
+                    return schema.SchemaName.ToPascalCase() + baseName;
                 }
                 return baseName;
             }
@@ -133,37 +133,5 @@ public override string GetDependentEndCandidateNavigationPropertyName(IForeignKe
         private Schema GetSchema(string originalSchema)
             => _customNameOptions?
                     .FirstOrDefault(x => x.SchemaName == originalSchema);
-
-        private static string ToPascalCase(string value)
-        {
-            var candidateStringBuilder = new StringBuilder();
-            var previousLetterCharInWordIsLowerCase = false;
-            var isFirstCharacterInWord = true;
-
-            foreach (var c in value)
-            {
-                var isNotLetterOrDigit = !char.IsLetterOrDigit(c);
-                if (isNotLetterOrDigit
-                    || (previousLetterCharInWordIsLowerCase && char.IsUpper(c)))
-                {
-                    isFirstCharacterInWord = true;
-                    previousLetterCharInWordIsLowerCase = false;
-                    if (isNotLetterOrDigit)
-                    {
-                        continue;
-                    }
-                }
-
-                candidateStringBuilder.Append(
-                    isFirstCharacterInWord ? char.ToUpperInvariant(c) : char.ToLowerInvariant(c));
-                isFirstCharacterInWord = false;
-                if (char.IsLower(c))
-                {
-                    previousLetterCharInWordIsLowerCase = true;
-                }
-            }
-
-            return candidateStringBuilder.ToString();
-        }
     }
 }

src/GUI/ReverseEngineer20/ReverseEngineer/StringExtension.cs

@@ -0,0 +1,39 @@
+using System.Text;
+
+namespace ReverseEngineer20.ReverseEngineer
+{
+    public static class StringExtension
+    {
+        public static string ToPascalCase(this string value)
+        {
+            var candidateStringBuilder = new StringBuilder();
+            var previousLetterCharInWordIsLowerCase = false;
+            var isFirstCharacterInWord = true;
+
+            foreach (var c in value)
+            {
+                var isNotLetterOrDigit = !char.IsLetterOrDigit(c);
+                if (isNotLetterOrDigit
+                    || (previousLetterCharInWordIsLowerCase && char.IsUpper(c)))
+                {
+                    isFirstCharacterInWord = true;
+                    previousLetterCharInWordIsLowerCase = false;
+                    if (isNotLetterOrDigit)
+                    {
+                        continue;
+                    }
+                }
+
+                candidateStringBuilder.Append(
+                    isFirstCharacterInWord ? char.ToUpperInvariant(c) : char.ToLowerInvariant(c));
+                isFirstCharacterInWord = false;
+                if (char.IsLower(c))
+                {
+                    previousLetterCharInWordIsLowerCase = true;
+                }
+            }
+
+            return candidateStringBuilder.ToString();
+        }
+    }
+}

src/GUI/ReverseEngineer20/ReverseEngineer20.csproj

@@ -283,6 +283,7 @@
     <Compile Include="EFCoreReverseEngineer.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ReverseEngineer\InflectorPluralizer.cs" />
+    <Compile Include="ReverseEngineer\StringExtension.cs" />
     <Compile Include="ServiceProviderBuilder.cs" />
   </ItemGroup>
   <ItemGroup>

src/GUI/ReverseEngineer20/ServiceProviderBuilder.cs

@@ -37,7 +37,8 @@ public static ServiceProvider Build(ReverseEngineerOptions options)
 
             if (options.CustomReplacers != null)
             {
-                serviceCollection.AddSingleton<ICandidateNamingService>(provider => new ReplacingCandidateNamingService(options.CustomReplacers));
+                serviceCollection.AddSingleton(options.CustomReplacers)
+                                 .AddSingleton<ICandidateNamingService, ReplacingCandidateNamingService>();
             }
 
             if (options.UseInflector)

src/GUI/UnitTests/PluralizerTest.cs

@@ -1,5 +1,7 @@
 using NUnit.Framework;
 using Humanizer;
+using System.Collections.Generic;
+using ReverseEngineer20.ReverseEngineer;
 
 namespace UnitTests
 {
@@ -405,5 +407,96 @@ public void Issue221(string word, string expectedResult)
             // Assert
             Assert.That(result, Is.EqualTo(expectedResult));
         }
+
+        [Test]
+        public void InflectorPluralizerVariables()
+        {
+            var expectedResult = "AndroidOtas";
+
+            var exampleOption = new List<Schema>
+              {
+                  new Schema
+                  {
+                       SchemaName = "machine",
+                       UseSchemaName = false,
+                       Tables = new List<TableRenamer>
+                       {
+                          new TableRenamer
+                          {
+                            Name = "android_ota",
+                            VariableName = "AndroidOtas",
+                          }
+                       }
+                  }
+              };
+
+            var sut = new InflectorPluralizer(exampleOption);
+
+            //Act
+            var result = sut.Pluralize("AndroidOta");
+
+            //Assert
+            Assert.That(result, Is.EqualTo(expectedResult));
+        }
+
+        [Test]
+        public void InflectorOriginalPluralizerVariables()
+        {
+            var expectedResult = "AndroidOtas";
+
+
+            var sut = new InflectorPluralizer();
+
+            //Act
+            var result = sut.Pluralize("AndroidOta");//output is AndroidOta
+
+            //Assert
+            Assert.That(result, Is.Not.EqualTo(expectedResult));
+        }
+
+        [Test]
+        public void InflectorSingularizeNewName()
+        {
+            var expectedResult = "WeatherData";
+
+            var exampleOption = new List<Schema>
+              {
+                  new Schema
+                  {
+                       SchemaName = "machine",
+                       UseSchemaName = false,
+                       Tables = new List<TableRenamer>
+                       {
+                          new TableRenamer
+                          {
+                            Name = "weather_data",
+                            NewName = "WeatherData",
+                          }
+                       }
+                  }
+              };
+
+            var sut = new InflectorPluralizer(exampleOption);
+
+            //Act
+            var result = sut.Singularize("WeatherData");
+
+            //Assert
+            Assert.That(result, Is.EqualTo(expectedResult));
+        }
+
+        [Test]
+        public void InflectorOriginalSingularizeNewName()
+        {
+            var expectedResult = "WeatherData";
+
+            var sut = new InflectorPluralizer();
+
+            //Act
+            var result = sut.Singularize("WeatherData"); // Output is WeatherDatum
+
+            //Assert
+            Assert.That(result, Is.Not.EqualTo(expectedResult));
+        }
     }
 }