refactor: Improved property handler

BREAKING CHANGE: Removed dependecy from `PowerUtils.Text`

Author: NelsonBN

README.md

@@ -39,7 +39,6 @@
 ## Dependencies <a name="dependencies"></a>
 
 - Microsoft.AspNetCore.App [NuGet](https://www.nuget.org/packages/Microsoft.AspNetCore.App/)
-- PowerUtils.Text [NuGet](https://www.nuget.org/packages/PowerUtils.Text/)
 
 
 

src/ApiProblemDetailsFactory.cs

@@ -13,8 +13,8 @@ internal sealed class ApiProblemDetailsFactory : ProblemDetailsFactory, IProblem
     {
         private readonly IHttpContextAccessor _httpContextAccessor;
 
-        private readonly ApiBehaviorOptions _apiBehaviorOptions;
-        private readonly ErrorHandlerOptions _errorHandlerOptions;
+        private readonly IOptions<ApiBehaviorOptions> _apiBehaviorOptions;
+        private readonly IOptions<ErrorHandlerOptions> _errorHandlerOptions;
 
         public ApiProblemDetailsFactory(
             IHttpContextAccessor httpContextAccessor,
@@ -24,8 +24,8 @@ IOptions<ErrorHandlerOptions> errorHandlerOptions
         {
             _httpContextAccessor = httpContextAccessor;
 
-            _apiBehaviorOptions = apiBehaviorOptions?.Value ?? throw new ArgumentNullException(nameof(apiBehaviorOptions));
-            _errorHandlerOptions = errorHandlerOptions?.Value ?? throw new ArgumentNullException(nameof(errorHandlerOptions));
+            _apiBehaviorOptions = apiBehaviorOptions;
+            _errorHandlerOptions = errorHandlerOptions;
         }
 
 
@@ -91,7 +91,7 @@ public ErrorProblemDetails Create(HttpContext httpContext, IEnumerable<KeyValueP
             {
                 problemDetails.Errors
                     .Add(
-                        _formatPropertyName(error.Key),
+                        _errorHandlerOptions.Value.PropertyHandler(error.Key),
                         error.Value
                     );
             }
@@ -186,7 +186,7 @@ private void _applyDefaults(HttpContext httpContext, ProblemDetails problemDetai
         {
             problemDetails.Status ??= httpContext.GetStatusCode();
 
-            if(_apiBehaviorOptions.ClientErrorMapping.TryGetValue(problemDetails.Status.Value, out var clientErrorData))
+            if(_apiBehaviorOptions.Value.ClientErrorMapping.TryGetValue(problemDetails.Status.Value, out var clientErrorData))
             {
                 problemDetails.Type ??= clientErrorData.Link;
                 problemDetails.Title ??= clientErrorData.Title;
@@ -225,14 +225,5 @@ private static void _applyDetail(ProblemDetails problemDetails)
                 _ => "An unexpected error has occurred."
             };
         }
-
-        // PropertyNamingPolicy.CamelCase is default value
-        private string _formatPropertyName(string propertyName)
-            => _errorHandlerOptions.PropertyNamingPolicy switch
-            {
-                PropertyNamingPolicy.Original => propertyName,
-                PropertyNamingPolicy.SnakeCase => propertyName.FormatToSnakeCase(),
-                _ => propertyName.FormatToCamelCase(),
-            };
     }
 }

src/ErrorHandlerOptions.cs

@@ -24,13 +24,24 @@ public class ExceptionMapper<TException> : IExceptionMapper
 
     public class ErrorHandlerOptions
     {
+        private PropertyNamingPolicy _propertyNamingPolicy = PropertyNamingPolicy.CamelCase;
         /// <summary>
         /// Default value: CamelCase
         /// </summary>
-        public PropertyNamingPolicy PropertyNamingPolicy { get; set; } = PropertyNamingPolicy.CamelCase;
+        public PropertyNamingPolicy PropertyNamingPolicy
+        {
+            get => _propertyNamingPolicy;
+            set
+            {
+                _propertyNamingPolicy = value;
+                PropertyHandler = Handlers.PropertyHandler.Create(_propertyNamingPolicy);
+            }
+        }
 
         public IDictionary<Type, IExceptionMapper> ExceptionMappers { get; set; } = new Dictionary<Type, IExceptionMapper>();
 
+        internal Func<string, string> PropertyHandler { get; set; }
+
         public ErrorHandlerOptions()
         {
             ExceptionMappers.Add(
@@ -48,6 +59,8 @@ public ErrorHandlerOptions()
                     Handler = (_) => (StatusCodes.Status504GatewayTimeout, new Dictionary<string, ErrorDetails>())
                 }
             );
+
+            PropertyHandler = Handlers.PropertyHandler.Create(_propertyNamingPolicy);
         }
     }
 

src/Handlers/PropertyHandler.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Globalization;
+using System.Text;
+
+namespace PowerUtils.AspNetCore.ErrorHandler.Handlers
+{
+    internal static class PropertyHandler
+    {
+        public static Func<string, string> Create(PropertyNamingPolicy propertyNamingPolicy)
+            => propertyNamingPolicy switch
+            {
+                PropertyNamingPolicy.Original => Original,
+                PropertyNamingPolicy.SnakeCase => SnakeCase,
+                _ => CamelCase,
+            };
+
+        public static string Original(string property) => property;
+
+        public static string CamelCase(string property)
+        {
+            if(string.IsNullOrWhiteSpace(property))
+            {
+                return "";
+            }
+
+            var propertyParts = property.Split('.');
+            for(var count = 0; count < propertyParts.Length; count++)
+            {
+                // Prevent System.IndexOutOfRangeException: 'Index was outside the bounds of the array.' for cases "Hello."
+                if(propertyParts[count].Length == 0)
+                {
+                    continue;
+                }
+
+                propertyParts[count] = char.ToLowerInvariant(propertyParts[count][0]) + propertyParts[count][1..];
+            }
+
+
+            return string.Join(".", propertyParts);
+        }
+
+        public static string SnakeCase(string property)
+        {
+            if(string.IsNullOrWhiteSpace(property))
+            {
+                return "";
+            }
+
+            var propertyParts = property.Split('.');
+
+            for(var count = 0; count < propertyParts.Length; count++)
+            {
+                propertyParts[count] = propertyParts[count].ToSnakeCase();
+            }
+
+
+            return string.Join(".", propertyParts);
+        }
+
+        /// <summary>
+        /// Convert a text to snake case format
+        /// </summary>
+        /// <param name="input">Text to be transformed</param>
+        /// <returns>Text transformed</returns>
+        public static string ToSnakeCase(this string input)
+        { // Reference1: https://stackoverflow.com/questions/63055621/how-to-convert-camel-case-to-snake-case-with-two-capitals-next-to-each-other
+          // Reference1: https://github.com/efcore/EFCore.NamingConventions/blob/main/EFCore.NamingConventions/Internal/SnakeCaseNameRewriter.cs
+            if(string.IsNullOrEmpty(input))
+            {
+                return input;
+            }
+
+            var builder = new StringBuilder(input.Length + Math.Min(2, input.Length / 5));
+            var previousCategory = default(UnicodeCategory?);
+
+            for(var currentIndex = 0; currentIndex < input.Length; currentIndex++)
+            {
+                var currentChar = input[currentIndex];
+                if(currentChar == '_')
+                {
+                    builder.Append('_');
+                    previousCategory = null;
+                    continue;
+                }
+
+                var currentCategory = char.GetUnicodeCategory(currentChar);
+                switch(currentCategory)
+                {
+                    case UnicodeCategory.UppercaseLetter:
+                    case UnicodeCategory.TitlecaseLetter:
+                        _snakeCaseHandleUppercaseLetterAndTitlecaseLetter(
+                            input,
+                            currentIndex,
+                            previousCategory,
+                            builder
+                        );
+
+                        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();
+        }
+
+        private static void _snakeCaseHandleUppercaseLetterAndTitlecaseLetter(string input, int currentIndex, UnicodeCategory? previousCategory, StringBuilder builder)
+        {
+            if(previousCategory == UnicodeCategory.SpaceSeparator ||
+                previousCategory == UnicodeCategory.LowercaseLetter ||
+                (previousCategory != UnicodeCategory.DecimalDigitNumber &&
+                previousCategory != null &&
+                currentIndex > 0 &&
+                currentIndex + 1 < input.Length &&
+                char.IsLower(input[currentIndex + 1])))
+            {
+                builder.Append('_');
+            }
+        }
+    }
+}

src/PowerUtils.AspNetCore.ErrorHandler.csproj

@@ -91,7 +91,6 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.App" Version="2.2.8" />
-    <PackageReference Include="PowerUtils.Text" Version="2.2.0" />
   </ItemGroup>