ParseQueryString (#8)

* ParseQueryString

Author: ricardotondello

README.md

@@ -140,6 +140,18 @@ Search for especial characters (not A to Z and not 0 to 9) in the string
 var result = "12.8/0';@#!%^&*()a12,9abc".OnlySpecialCharacters(); //"./';@#!%^&*(),"
 ```
 
+### `ParseQueryString`
+
+Parses a query string into a dictionary of key-value pairs.
+
+**Usage**
+```csharp
+var queryString = "?name=JohnDoe&age=30&isMember=true";
+var result = queryString.ParseQueryString(autoConvertType: true);
+// result will be a dictionary with keys "name", "age", "isMember"
+// and corresponding values "JohnDoe", 30, true
+```
+
 ## Contributing 👥
 
 Contributions are welcome! If you find a bug or have a feature request, please open an issue on GitHub.

docs/NuGet.md

@@ -132,4 +132,16 @@ Search for especial characters (not A to Z and not 0 to 9) in the string
 **Usage**
 ```csharp
 var result = "12.8/0';@#!%^&*()a12,9abc".OnlySpecialCharacters(); //"./';@#!%^&*(),"
+```
+
+### `ParseQueryString`
+
+Parses a query string into a dictionary of key-value pairs.
+
+**Usage**
+```csharp
+var queryString = "?name=JohnDoe&age=30&isMember=true";
+var result = queryString.ParseQueryString(autoConvertType: true);
+// result will be a dictionary with keys "name", "age", "isMember"
+// and corresponding values "JohnDoe", 30, true
 ```

global.json

@@ -1,6 +1,6 @@
 {
   "sdk": {
-    "version": "6.0.0",
+    "version": "8.0.0",
     "rollForward": "latestMinor",
     "allowPrerelease": false
   }

src/FunctionalStringExtensions.cs

@@ -1,15 +1,19 @@
 using System;
+using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using System.Web;
 
 namespace FunctionalStringExtensions;
 
 public static class FunctionalStringExtensions
 {
     private static readonly object Lock = new();
     private static readonly TimeSpan RegexTimeOut = TimeSpan.FromMilliseconds(100);
+    private static readonly IDictionary<string, object> EmptyQueryDictionary = new Dictionary<string, object>(0);
 
     /// <summary>
     /// This extension method returns the provided default value if the input string is null or empty.
@@ -110,7 +114,7 @@ public static T ToEnum<T>(this string? value, T @default = default) where T : st
     /// <summary>
     /// Search for letters (A to Z) in the string
     /// </summary>
-    /// <param name="value">input string</param>
+    /// <param name="value">Input <see cref="string"/> value</param>
     /// <returns>The letters present in the string provided</returns>
     public static string OnlyLetters(this string? value)
     {
@@ -120,7 +124,7 @@ public static string OnlyLetters(this string? value)
     /// <summary>
     /// Search for numbers (0 to 9) in the string
     /// </summary>
-    /// <param name="value">input string</param>
+    /// <param name="value">Input <see cref="string"/> value</param>
     /// <returns>The numbers present in the string provided</returns>
     public static string OnlyNumbers(this string? value)
     {
@@ -130,7 +134,7 @@ public static string OnlyNumbers(this string? value)
     /// <summary>
     /// Search for characters and numbers (A to Z or 0 to 9) in the string
     /// </summary>
-    /// <param name="value">input string</param>
+    /// <param name="value">Input <see cref="string"/> value</param>
     /// <returns>The characters and numbers present in the string provided</returns>
     public static string OnlyCharactersAndNumbers(this string? value)
     {
@@ -140,12 +144,77 @@ public static string OnlyCharactersAndNumbers(this string? value)
     /// <summary>
     /// Search for especial characters (not A to Z and not 0 to 9) in the string
     /// </summary>
-    /// <param name="value">input string</param>
+    /// <param name="value">Input <see cref="string"/> value</param>
     /// <returns>The especial characters present in the string provided</returns>
     public static string OnlySpecialCharacters(this string? value)
     {
         return value.FilterCharacters(c => !char.IsLetterOrDigit(c));
     }
+
+    /// <summary>
+    /// Parses a query string into a dictionary of key-value pairs.
+    /// </summary>
+    /// <param name="value">The input query string.</param>
+    /// <param name="autoConvertType">Indicates whether to automatically convert the query values to their appropriate types (e.g., int, bool, double). Default is false.</param>
+    /// <returns>
+    /// A dictionary containing the parsed query parameters as key-value pairs. The keys are strings, and the values are objects.
+    /// If the input string is null or empty, an empty dictionary is returned.
+    /// </returns>
+    public static IDictionary<string, object> ParseQueryString(this string? value, bool autoConvertType = false)
+    {
+        var index = value?.IndexOf('?') ?? -1; 
+        if (string.IsNullOrEmpty(value) || index < 0)
+        {
+            return EmptyQueryDictionary;
+        }
+
+        var query = value[0] == '?' 
+            ? value.TrimStart('?') 
+            : value.Substring(index + 1, value.Length - index - 1);
+
+        if (string.IsNullOrEmpty(query))
+        {
+            return EmptyQueryDictionary;
+        }
+        
+        return query
+            .Split('&', StringSplitOptions.RemoveEmptyEntries)
+            .Select(part => part.Split('='))
+            .ToDictionary(
+                part => HttpUtility.UrlDecode(part[0]), 
+                part =>
+                {
+                    var partValue = MaybeGetValue(part);
+                    var decodedValue = HttpUtility.UrlDecode(partValue);
+                    return autoConvertType ? ConvertToType(decodedValue) : decodedValue;
+                });
+
+        string MaybeGetValue(string[] partValue)
+        {
+            return partValue.Length < 2 ? string.Empty : partValue[1];
+        }
+        
+        object ConvertToType(string valueToConvert)
+        {
+            if (int.TryParse(valueToConvert, NumberStyles.Integer, CultureInfo.InvariantCulture, out var intValue))
+            {
+                return intValue;
+            }
+
+            if (bool.TryParse(valueToConvert, out var boolValue))
+            {
+                return boolValue;
+            }
+
+            if (double.TryParse(valueToConvert, NumberStyles.Float | NumberStyles.AllowThousands, 
+                    CultureInfo.InvariantCulture, out var doubleValue))
+            {
+                return doubleValue;
+            }
+        
+            return valueToConvert;
+        }
+    }
 
     private static string FilterCharacters(this string? value, Func<char, bool> predicate)
     {

tests/FunctionalStringExtensionsTests/FunctionalStringExtensionsTests.cs

@@ -272,6 +272,92 @@ public void OnlySpecialCharactersShouldReturnOnlySpecialCharacters(string? value
         //Assert
         result.Should().Be(expected);
     }
+
+    [Theory]
+    [InlineData(null)]
+    [InlineData("")]
+    [InlineData("not a valid url")]
+    [InlineData("?")]
+    public void ParseQueryString_ShouldReturnEmptyListWhenNotAValidInput(string? value)
+    {
+        var result = value.ParseQueryString();
+
+        result.Should().BeEmpty();
+    }
+    
+    [Theory]
+    [InlineData("http://yoursite.com?variable1=false", "variable1",  false)]
+    [InlineData("http://yoursite.com?variable1=False", "variable1", false)]
+    [InlineData("http://yoursite.com?variable1=1", "variable1", 1)]
+    [InlineData("http://yoursite.com?variable1=19.86", "variable1", 19.86)]
+    [InlineData("?variable1=true", "variable1", true)]
+    [InlineData("?variable1=True", "variable1", true)]
+    [InlineData("?variable1=1", "variable1", 1)]
+    [InlineData("?variable1=0.77", "variable1", 0.77)]
+    [InlineData("?variable1=test", "variable1", "test")]
+    public void ParseQueryString_ConvertType_ShouldReturnListOfKeyValues(string? value, string expectedKey, object expectedValue)
+    {
+        var result = value.ParseQueryString(autoConvertType: true);
+
+        result.Should().NotBeEmpty();
+        result.Should().HaveCount(1);
+        result.First().Key.Should().Be(expectedKey);
+        result.First().Value.Should().Be(expectedValue);
+        result.First().Value.Should().BeOfType(expectedValue.GetType());
+    }
+    
+    [Theory]
+    [InlineData("http://yoursite.com?variable1=false", "variable1",  "false")]
+    [InlineData("http://yoursite.com?variable1=False", "variable1", "False")]
+    [InlineData("http://yoursite.com?variable1=1", "variable1", "1")]
+    [InlineData("http://yoursite.com?variable1=19.86", "variable1", "19.86")]
+    [InlineData("?variable1=true", "variable1", "true")]
+    [InlineData("?variable1=True", "variable1", "True")]
+    [InlineData("?variable1=1", "variable1", "1")]
+    [InlineData("?variable1=0.77", "variable1", "0.77")]
+    [InlineData("?variable1=test", "variable1", "test")]
+    public void ParseQueryString_WithoutConversion_ShouldReturnListOfKeyValues(string? value, string expectedKey, string expectedValue)
+    {
+        var result = value.ParseQueryString(autoConvertType: false);
+
+        result.Should().NotBeEmpty();
+        result.Should().HaveCount(1);
+        result.First().Key.Should().Be(expectedKey);
+        result.First().Value.Should().Be(expectedValue);
+        result.First().Value.Should().BeOfType<string>();
+    }
+    
+    [Theory]
+    [InlineData("?variable1=15&variable2=is that a question?&variable3=true&variable4=33.88&variable5=", "variable1=15|variable2=is that a question?|variable3=true|variable4=33.88|variable5=")]
+    public void ParseQueryString_ShouldReturnListOfKeyValues(string? value, string expectedPipedString)
+    {
+         var result = value.ParseQueryString(autoConvertType: false);
+    
+         var expected = expectedPipedString
+             .Split('|', StringSplitOptions.RemoveEmptyEntries)
+             .Select(s => s.Split('='))
+             .ToDictionary(k => k[0], v => v[1]);
+         
+        result.Should().NotBeEmpty();
+        result.Should().BeEquivalentTo(expected);
+    }
+    
+    [Theory]
+    [InlineData("?not a valid url", "not a valid url=")]
+    [InlineData("?not a valid url&&&&&", "not a valid url=")]
+    [InlineData("?not a valid url&&&&&=value", "not a valid url=|=value")]
+    public void ParseQueryString_EdgeCasesShouldReturnListOfKeyValues(string? value, string expectedPipedString)
+    {
+        var result = value.ParseQueryString(autoConvertType: false);
+    
+        var expected = expectedPipedString
+            .Split('|')
+            .Select(s => s.Split('='))
+            .ToDictionary(k => k.Length > 0? k[0] : string.Empty, v => v.Length > 1 ? v[1]: string.Empty);
+         
+        result.Should().NotBeEmpty();
+        result.Should().BeEquivalentTo(expected);
+    }
 }
 
 public enum FakeEnum

tests/FunctionalStringExtensionsTests/FunctionalStringExtensionsTests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>