✨ feature: Add Split Camel Case Extension (#53)

* 📜 docs: Update API

* ✨ feature: Create Split Camel Case Extension

* 🚨 tests: Create Split Camel Case Tests

* ✨ feature: Add null case

* 🚨 tests: Add null case test

* 📜 docs: Update Changelog

Author: TylerCarrol

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Split camel case extension
+
 ## [0.3.0] - 2024-10-20
 
 ### Added

TJC.StringExtensions.Tests/Cases/CamelCaseExtensionsTests.cs

@@ -0,0 +1,49 @@
+using TJC.StringExtensions.Cases;
+
+namespace TJC.StringExtensions.Tests.Cases;
+
+[TestClass]
+public class CamelCaseExtensionsTests
+{
+    [TestMethod]
+    public void SplitCamelCase_Null_ReturnsEmpty()
+    {
+        // Arrange
+        string? input = null;
+        var expected = string.Empty;
+
+        // Act
+        var result = input.SplitCamelCase();
+
+        // Assert
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void SplitCamelCase_FirstLetterLowercase_SplitsWithSpace()
+    {
+        // Arrange
+        var input = "camelCaseExtensions";
+        var expected = "camel Case Extensions";
+
+        // Act
+        var result = input.SplitCamelCase();
+
+        // Assert
+        Assert.AreEqual(expected, result);
+    }
+
+    [TestMethod]
+    public void SplitCamelCase_FirstLetterUppercase_SplitsWithSpace()
+    {
+        // Arrange
+        var input = "CamelCaseExtensions";
+        var expected = "Camel Case Extensions";
+
+        // Act
+        var result = input.SplitCamelCase();
+
+        // Assert
+        Assert.AreEqual(expected, result);
+    }
+}

TJC.StringExtensions/Cases/CamelCaseExtensions.cs

@@ -0,0 +1,24 @@
+namespace TJC.StringExtensions.Cases;
+
+/// <summary>
+/// Camel case extensions for strings.
+/// <para></para>
+/// Example of camel case: "camelCaseExtensions"
+/// </summary>
+public static class CamelCaseExtensions
+{
+    /// <summary>
+    /// Split camel case with a separator (typically a space).
+    /// <para></para>
+    /// Example: "camelCaseExtensions" becomes "camel Case Extensions"
+    /// </summary>
+    /// <param name="input"></param>
+    /// <param name="separator"></param>
+    /// <returns></returns>
+    public static string SplitCamelCase(this string? input, string separator = " ")
+    {
+        if (string.IsNullOrEmpty(input))
+            return string.Empty;
+        return string.Concat(input.Select((x, i) => i > 0 && char.IsUpper(x) ? $"{separator}{x}" : x.ToString()));
+    }
+}

TJC.StringExtensions/Header/HeaderExtensions.cs

@@ -1,29 +1,42 @@
 using TJC.StringExtensions.Lines;
 using TJC.StringExtensions.Padding;
 
-namespace TJC.StringExtensions.Header
+namespace TJC.StringExtensions.Header;
+
+/// <summary>
+/// Extensions for creating text headers.
+/// </summary>
+public static class HeaderExtensions
 {
-    public static class HeaderExtensions
+    /// <summary>
+    /// Create a text header with a border of specified characters.
+    /// <para></para>
+    /// For use within console applications.
+    /// </summary>
+    /// <param name="lines"></param>
+    /// <param name="internalLineLimit"></param>
+    /// <param name="character"></param>
+    /// <param name="linePrefix"></param>
+    /// <param name="lineSuffix"></param>
+    /// <returns></returns>
+    public static IEnumerable<string> GenerateHeader(this IEnumerable<string> lines, int internalLineLimit = 70, char character = '#', string linePrefix = "###   ", string lineSuffix = "   ###")
     {
-        public static IEnumerable<string> GenerateHeader(this IEnumerable<string> lines, int internalLineLimit = 70, char character = '#', string linePrefix = "###   ", string lineSuffix = "   ###")
-        {
-            var tempLines = new List<string>();
-            // Get lines
-            foreach (var newLine in lines)
-                foreach (var splitLine in newLine.SplitNewLine())
-                    foreach (var line in splitLine.SplitLines(internalLineLimit))
-                        tempLines.Add(line);
+        var tempLines = new List<string>();
+        // Get lines
+        foreach (var newLine in lines)
+            foreach (var splitLine in newLine.SplitNewLine())
+                foreach (var line in splitLine.SplitLines(internalLineLimit))
+                    tempLines.Add(line);
 
-            // Get border
-            var longestLine = tempLines.Max(x => x.Length);
-            var headerBorder = new string(character, longestLine + linePrefix.Length + lineSuffix.Length);
+        // Get border
+        var longestLine = tempLines.Max(x => x.Length);
+        var headerBorder = new string(character, longestLine + linePrefix.Length + lineSuffix.Length);
 
-            // Get lines with prefix and suffix
-            var headerLines = new List<string> { headerBorder };
-            foreach (var line in tempLines)
-                headerLines.Add($"{linePrefix}{line.PadBoth(longestLine)}{lineSuffix}");
-            headerLines.Add(headerBorder);
-            return headerLines;
-        }
+        // Get lines with prefix and suffix
+        var headerLines = new List<string> { headerBorder };
+        foreach (var line in tempLines)
+            headerLines.Add($"{linePrefix}{line.PadBoth(longestLine)}{lineSuffix}");
+        headerLines.Add(headerBorder);
+        return headerLines;
     }
 }

TJC.StringExtensions/Lines/LineExtensions.cs

@@ -1,5 +1,8 @@
 namespace TJC.StringExtensions.Lines;
 
+/// <summary>
+/// Extensions for lines of text.
+/// </summary>
 public static class LineExtensions
 {
     private const int MaxLineWidth = 60;

TJC.StringExtensions/Padding/PaddingExtensions.cs

@@ -1,7 +1,16 @@
 namespace TJC.StringExtensions.Padding;
 
+/// <summary>
+/// Padding extensions for strings.
+/// </summary>
 public static class PaddingExtension
 {
+    /// <summary>
+    /// Pad a string with spaces on both sides to make it the specified length.
+    /// </summary>
+    /// <param name="source"></param>
+    /// <param name="length"></param>
+    /// <returns></returns>
     public static string PadBoth(this string source, int length)
     {
         var spaces = length - source.Length;

TJC.StringExtensions/Parsing/StringParserExtensions.cs

@@ -2,58 +2,61 @@
 
 namespace TJC.StringExtensions.Parsing;
 
+/// <summary>
+/// Parsing extensions for strings.
+/// </summary>
 public static partial class StringParserExtensions
 {
     /// <summary>
-    /// Keep Alpha Only
+    /// Keep Alpha Only.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
     public static string KeepAlpha(this string str) => AlphaRegex().Replace(str, string.Empty);
     [GeneratedRegex("[^a-zA-Z]")] public static partial Regex AlphaRegex();
 
     /// <summary>
-    /// Keep Numeric Only
+    /// Keep Numeric Only.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
     public static string KeepNumeric(this string str) => NumericRegex().Replace(str, string.Empty);
     [GeneratedRegex("[^0-9]")] public static partial Regex NumericRegex();
 
     /// <summary>
-    /// Keep Numeric & Period
+    /// Keep Numeric &amp; Period.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
     public static string KeepNumericAndPeriod(this string str) => NumericAndPeriodRegex().Replace(str, string.Empty);
     [GeneratedRegex("[^0-9.]")] public static partial Regex NumericAndPeriodRegex();
 
     /// <summary>
-    /// Keep Alpha & Numeric
+    /// Keep Alpha &amp; Numeric.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
     public static string KeepAlphaNumeric(this string str) => AlphaNumericRegex().Replace(str, string.Empty);
     [GeneratedRegex("[^a-zA-Z0-9]")] public static partial Regex AlphaNumericRegex();
 
     /// <summary>
-    /// Keep Alpha, Numeric & Space
+    /// Keep Alpha, Numeric &amp; Space.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
     public static string KeepAlphaNumericAndSpace(this string str) => AlphaNumericAndSpaceRegex().Replace(str, string.Empty);
     [GeneratedRegex("[^a-zA-Z0-9 ]")] public static partial Regex AlphaNumericAndSpaceRegex();
 
     /// <summary>
-    /// Keep Alpha, Numeric, Space & Period
+    /// Keep Alpha, Numeric, Space &amp; Period.
     /// </summary>
     /// <param name="str"></param>
     /// <returns></returns>
     public static string KeepAlphaNumericSpaceAndPeriod(this string str) => AlphaNumericSpaceAndPeriodRegex().Replace(str, string.Empty);
     [GeneratedRegex("[^a-zA-Z0-9. ]")] public static partial Regex AlphaNumericSpaceAndPeriodRegex();
 
     /// <summary>
-    /// Keep Only Alpha, Numeric, Spaces, & Excluded Symbols
+    /// Keep Only Alpha, Numeric, Spaces, &amp; Excluded Symbols.
     /// </summary>
     /// <param name="str"></param>
     /// <param name="exceptions"></param>

TJC.StringExtensions/Pluralize/PluralizeExtensions.cs

@@ -1,5 +1,8 @@
 namespace TJC.StringExtensions.Pluralize;
 
+/// <summary>
+/// Extensions for pluralizing strings.
+/// </summary>
 public static class PluralizeExtensions
 {
     /// <summary>