Added String IsLike extension method for comparing string against a wildcard pattern

Author: jamesmcroft

src/MADE.Data.Validation/Extensions/StringExtensions.cs

@@ -5,6 +5,7 @@ namespace MADE.Data.Validation.Extensions
 {
     using System;
     using System.Globalization;
+    using System.Text.RegularExpressions;
 
     /// <summary>
     /// Defines a collection of extensions for string values.
@@ -43,6 +44,43 @@ public static bool Contains(this string phrase, string value, CompareOptions com
             return CultureInfo.CurrentCulture.CompareInfo.IndexOf(phrase, value, compareOption) >= 0;
         }
 
+        /// <summary>
+        /// Compares a string value against a wildcard pattern, similar to the Visual Basic like operator.
+        /// </summary>
+        /// <remarks>
+        /// An example of this in use comparing strings with * wildcard pattern.
+        /// <code>
+        ///   // result is true
+        ///   bool result = "MyValue".IsLike("My*");
+        ///
+        ///   // result is false
+        ///   result = "MyValue".IsLike("Hello");
+        /// </code>
+        /// </remarks>
+        /// <param name="value">The value to compare is like.</param>
+        /// <param name="likePattern">The wildcard like pattern to match on.</param>
+        /// <returns>True if the value is like the pattern; otherwise, false.</returns>
+        public static bool IsLike(this string value, string likePattern)
+        {
+            if (value.IsNullOrWhiteSpace() || likePattern.IsNullOrWhiteSpace())
+            {
+                return false;
+            }
+
+            // Escape any special characters in pattern
+            var regex = "^" + Regex.Escape(likePattern) + "$";
+
+            // Replace wildcard characters with regular expression equivalents
+            regex = regex.Replace(@"\[!", "[^")
+                .Replace(@"\[", "[")
+                .Replace(@"\]", "]")
+                .Replace(@"\?", ".")
+                .Replace(@"\*", ".*")
+                .Replace(@"\#", @"\d");
+
+            return Regex.IsMatch(value, regex);
+        }
+
         /// <summary>
         /// Checks whether a string value is an integer.
         /// </summary>

tests/MADE.Data.Validation.Tests/Tests/StringExtensionsTests.cs

@@ -2,14 +2,35 @@ namespace MADE.Data.Validation.Tests.Tests
 {
     using System.Diagnostics.CodeAnalysis;
     using System.Globalization;
-    using Extensions;
+    using MADE.Data.Validation.Extensions;
     using NUnit.Framework;
     using Shouldly;
 
     [ExcludeFromCodeCoverage]
     [TestFixture]
     public class StringExtensionsTests
     {
+        public class WhenValidatingIfStringIsLike
+        {
+            [TestCase("*", "abc", true)]
+            [TestCase("a*", "abc", true)]
+            [TestCase("a?c", "abc", true)]
+            [TestCase("[a-z][a-z][a-z]", "abc", true)]
+            [TestCase("###", "123", true)]
+            [TestCase("###", "abc", false)]
+            [TestCase("*###", "123abc", false)]
+            [TestCase("[a-z][a-z][a-z]", "ABC", false)]
+            [TestCase("a?c", "aba", false)]
+            public void ShouldMatchPattern(string pattern, string input, bool expected)
+            {
+                // Act
+                var actual = input.IsLike(pattern);
+
+                // Assert
+                actual.ShouldBe(expected);
+            }
+        }
+
         public class WhenCheckingIfStringContainsValue
         {
             [TestCase("Hello, World", "ello", CompareOptions.None)]
@@ -141,4 +162,4 @@ public void ShouldReturnFalseIfNotFloat(string value)
             }
         }
     }
-}
+}